@wdio/utils 9.0.0-alpha.9 → 9.0.4

package/build/node/utils.js

@@ -1,285 +0,0 @@
-import os from 'node:os';
-import fs from 'node:fs';
-import fsp from 'node:fs/promises';
-import path from 'node:path';
-import cp from 'node:child_process';
-import decamelize from 'decamelize';
-import logger from '@wdio/logger';
-import { install, canDownload, resolveBuildId, detectBrowserPlatform, Browser, ChromeReleaseChannel, computeExecutablePath } from '@puppeteer/browsers';
-import { download as downloadGeckodriver } from 'geckodriver';
-import { download as downloadEdgedriver } from 'edgedriver';
-import { locateChrome, locateFirefox, locateApp } from 'locate-app';
-const log = logger('webdriver');
-const EXCLUDED_PARAMS = ['version', 'help'];
-/**
- * Helper utility to check file access
- * @param {string} file file to check access for
- * @return              true if file can be accessed
- */
-export const canAccess = (file) => {
-    if (!file) {
-        return false;
-    }
-    try {
-        fs.accessSync(file);
-        return true;
-    }
-    catch (err) {
-        return false;
-    }
-};
-export function parseParams(params) {
-    return Object.entries(params)
-        .filter(([key,]) => !EXCLUDED_PARAMS.includes(key))
-        .map(([key, val]) => {
-        if (typeof val === 'boolean' && !val) {
-            return '';
-        }
-        const vals = Array.isArray(val) ? val : [val];
-        return vals.map((v) => `--${decamelize(key, { separator: '-' })}${typeof v === 'boolean' ? '' : `=${v}`}`);
-    })
-        .flat()
-        .filter(Boolean);
-}
-export function getBuildIdByChromePath(chromePath) {
-    if (!chromePath) {
-        return;
-    }
-    if (os.platform() === 'win32') {
-        const versionPath = path.dirname(chromePath);
-        const contents = fs.readdirSync(versionPath);
-        const versions = contents.filter(a => /^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+$/g.test(a));
-        // returning oldest in case there is an updated version and chrome still hasn't relaunched
-        const oldest = versions.sort((a, b) => a > b ? -1 : 1)[0];
-        return oldest;
-    }
-    const versionString = cp.execSync(`"${chromePath}" --version --no-sandbox`).toString();
-    const versionSanitized = versionString.trim().split(' ').find((s) => s.split('.').length === 4);
-    if (!versionSanitized) {
-        throw new Error(`Couldn't find valid Chrome version from "${versionString}", please raise an issue in the WebdriverIO project (https://github.com/webdriverio/webdriverio/issues/new/choose)`);
-    }
-    return versionSanitized;
-}
-export async function getBuildIdByFirefoxPath(firefoxPath) {
-    if (!firefoxPath) {
-        return;
-    }
-    if (os.platform() === 'win32') {
-        const appPath = path.dirname(firefoxPath);
-        const contents = (await fsp.readFile(path.join(appPath, 'application.ini'))).toString('utf-8');
-        return contents
-            .split('\n')
-            .filter((line) => line.startsWith('Version='))
-            .map((line) => line.replace('Version=', '').replace(/\r/, ''))
-            .pop();
-    }
-    const versionString = cp.execSync(`"${firefoxPath}" --version`).toString();
-    return versionString.trim().split(' ').pop()?.trim();
-}
-let lastTimeCalled = Date.now();
-export const downloadProgressCallback = (artifact, downloadedBytes, totalBytes) => {
-    if (Date.now() - lastTimeCalled < 1000) {
-        return;
-    }
-    const percentage = ((downloadedBytes / totalBytes) * 100).toFixed(2);
-    log.progress(`Downloading ${artifact} ${percentage}%`);
-    lastTimeCalled = Date.now();
-};
-/**
- * Installs a package using the provided installation options and clears the progress log afterward.
- *
- * @description
- * When installing a package, progress updates are logged using `log.progress`.
- * To ensure the formatting of subsequent logs is not disrupted, it's essential to clear the progress log after the installation is complete.
- * This method combines the installation step and the clearing of the progress log.
- *
- * @see {@link https://github.com/webdriverio/webdriverio/blob/main/packages/wdio-logger/README.md#custom-log-levels} for more information.
- *
- * @param {InstallOptions & { unpack?: true | undefined }} args - An object containing installation options and an optional `unpack` flag.
- * @returns {Promise<void>} A Promise that resolves once the package is installed and clear the progress log.
- */
-const _install = async (args, retry = false) => {
-    await install(args).catch((err) => {
-        const error = `Failed downloading ${args.browser} v${args.buildId}: ${err.message}, retrying ...`;
-        if (retry) {
-            throw new Error(error);
-        }
-        log.error(error);
-        return _install(args, true);
-    });
-    log.progress('');
-};
-function locateChromeSafely() {
-    return locateChrome().catch(() => undefined);
-}
-export async function setupPuppeteerBrowser(cacheDir, caps) {
-    caps.browserName = caps.browserName?.toLowerCase();
-    const browserName = caps.browserName === Browser.FIREFOX
-        ? Browser.FIREFOX
-        : caps.browserName === Browser.CHROMIUM
-            ? Browser.CHROMIUM
-            : Browser.CHROME;
-    const exist = await fsp.access(cacheDir).then(() => true, () => false);
-    const isChromeOrChromium = browserName === Browser.CHROME || caps.browserName === Browser.CHROMIUM;
-    if (!exist) {
-        await fsp.mkdir(cacheDir, { recursive: true });
-    }
-    /**
-     * in case we run Chromium tests we have to switch back to browserName: 'chrome'
-     * as 'chromium' is not recognised as a valid browser name by Chromedriver
-     */
-    if (browserName === Browser.CHROMIUM) {
-        caps.browserName = Browser.CHROME;
-    }
-    /**
-     * don't set up Chrome/Firefox if a binary was defined in caps
-     */
-    const browserOptions = (isChromeOrChromium
-        ? caps['goog:chromeOptions']
-        : caps['moz:firefoxOptions']) || {};
-    if (typeof browserOptions.binary === 'string') {
-        return {
-            executablePath: browserOptions.binary,
-            browserVersion: (caps.browserVersion ||
-                (isChromeOrChromium
-                    ? getBuildIdByChromePath(browserOptions.binary)
-                    : await getBuildIdByFirefoxPath(browserOptions.binary)))
-        };
-    }
-    const platform = detectBrowserPlatform();
-    if (!platform) {
-        throw new Error('The current platform is not supported.');
-    }
-    if (!caps.browserVersion) {
-        const executablePath = browserName === Browser.CHROME
-            ? await locateChromeSafely()
-            : browserName === Browser.CHROMIUM
-                ? await locateApp({
-                    appName: Browser.CHROMIUM,
-                    macOsName: Browser.CHROMIUM,
-                    linuxWhich: 'chromium-browser'
-                }).catch(() => undefined)
-                : await locateFirefox().catch(() => undefined);
-        const tag = isChromeOrChromium
-            ? getBuildIdByChromePath(executablePath)
-            : await getBuildIdByFirefoxPath(executablePath);
-        /**
-         * verify that we have a valid Chrome/Firefox browser installed
-         */
-        if (tag) {
-            return {
-                executablePath,
-                browserVersion: await resolveBuildId(browserName, platform, tag)
-            };
-        }
-    }
-    /**
-     * otherwise download provided Chrome/Firefox browser version or "stable"
-     */
-    const tag = browserName === Browser.CHROME
-        ? caps.browserVersion || ChromeReleaseChannel.STABLE
-        : caps.browserVersion || 'latest';
-    const buildId = await resolveBuildId(browserName, platform, tag);
-    const installOptions = {
-        unpack: true,
-        cacheDir,
-        platform,
-        buildId,
-        browser: browserName,
-        downloadProgressCallback: (downloadedBytes, totalBytes) => downloadProgressCallback(`${browserName} (${buildId})`, downloadedBytes, totalBytes)
-    };
-    const isCombinationAvailable = await canDownload(installOptions);
-    if (!isCombinationAvailable) {
-        throw new Error(`Couldn't find a matching ${browserName} browser for tag "${buildId}" on platform "${platform}"`);
-    }
-    log.info(`Setting up ${browserName} v${buildId}`);
-    await _install(installOptions);
-    const executablePath = computeExecutablePath(installOptions);
-    /**
-     * for Chromium browser `resolveBuildId` returns with a useless build id
-     * which will not find a Chromedriver, therefor we need to resolve the
-     * id using Chrome as browser name
-     */
-    let browserVersion = buildId;
-    if (browserName === Browser.CHROMIUM) {
-        browserVersion = await resolveBuildId(Browser.CHROME, platform, tag);
-    }
-    return { executablePath, browserVersion };
-}
-export function getDriverOptions(caps) {
-    return (caps['wdio:chromedriverOptions'] ||
-        caps['wdio:geckodriverOptions'] ||
-        caps['wdio:edgedriverOptions'] ||
-        // Safaridriver does not have any options as it already
-        // is installed on macOS
-        {});
-}
-export function getCacheDir(options, caps) {
-    const driverOptions = getDriverOptions(caps);
-    return driverOptions.cacheDir || options.cacheDir || os.tmpdir();
-}
-export function getMajorVersionFromString(fullVersion) {
-    let prefix;
-    if (fullVersion) {
-        prefix = fullVersion.match(/^[+-]?([0-9]+)/);
-    }
-    return prefix && prefix.length > 0 ? prefix[0] : '';
-}
-export async function setupChromedriver(cacheDir, driverVersion) {
-    const platform = detectBrowserPlatform();
-    if (!platform) {
-        throw new Error('The current platform is not supported.');
-    }
-    const version = driverVersion || getBuildIdByChromePath(await locateChromeSafely()) || ChromeReleaseChannel.STABLE;
-    const buildId = await resolveBuildId(Browser.CHROMEDRIVER, platform, version);
-    let executablePath = computeExecutablePath({
-        browser: Browser.CHROMEDRIVER,
-        buildId,
-        platform,
-        cacheDir
-    });
-    const hasChromedriverInstalled = await fsp.access(executablePath).then(() => true, () => false);
-    if (!hasChromedriverInstalled) {
-        log.info(`Downloading Chromedriver v${buildId}`);
-        const chromedriverInstallOpts = {
-            cacheDir,
-            buildId,
-            platform,
-            browser: Browser.CHROMEDRIVER,
-            unpack: true,
-            downloadProgressCallback: (downloadedBytes, totalBytes) => downloadProgressCallback('Chromedriver', downloadedBytes, totalBytes)
-        };
-        let knownBuild = buildId;
-        if (await canDownload(chromedriverInstallOpts)) {
-            await _install({ ...chromedriverInstallOpts, buildId });
-            log.info(`Download of Chromedriver v${buildId} was successful`);
-        }
-        else {
-            log.warn(`Chromedriver v${buildId} don't exist, trying to find known good version...`);
-            knownBuild = await resolveBuildId(Browser.CHROMEDRIVER, platform, getMajorVersionFromString(version));
-            if (knownBuild) {
-                await _install({ ...chromedriverInstallOpts, buildId: knownBuild });
-                log.info(`Download of Chromedriver v${knownBuild} was successful`);
-            }
-            else {
-                throw new Error(`Couldn't download any known good version from Chromedriver major v${getMajorVersionFromString(version)}, requested full version - v${version}`);
-            }
-        }
-        executablePath = computeExecutablePath({
-            browser: Browser.CHROMEDRIVER,
-            buildId: knownBuild,
-            platform,
-            cacheDir
-        });
-    }
-    else {
-        log.info(`Using Chromedriver v${buildId} from cache directory ${cacheDir}`);
-    }
-    return { executablePath };
-}
-export function setupGeckodriver(cacheDir, driverVersion) {
-    return downloadGeckodriver(driverVersion, cacheDir);
-}
-export function setupEdgedriver(cacheDir, driverVersion) {
-    return downloadEdgedriver(driverVersion, cacheDir);
-}

package/build/pIteration.js

@@ -1,347 +0,0 @@
-/**
- * Implements ES5 [`Array#forEach()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) method.<br><br>
- * Executes the provided callback once for each element.<br>
- * Callbacks are run concurrently,
- * and are only invoked for properties of the array that have been initialized (including those initialized with *undefined*), for unassigned ones `callback` is not run.<br>
- * @param {Array} array - Array to iterate over.
- * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
- * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
- * @return {Promise} - Returns a Promise with undefined value.
- */
-export const forEach = async (array, callback, thisArg) => {
-    const promiseArray = [];
-    for (let i = 0; i < array.length; i++) {
-        if (i in array) {
-            const p = Promise.resolve(array[i]).then((currentValue) => {
-                return callback.call(thisArg || this, currentValue, i, array);
-            });
-            promiseArray.push(p);
-        }
-    }
-    await Promise.all(promiseArray);
-};
-/**
- * Same functionality as [`forEach()`](global.html#forEach), but runs only one callback at a time.
- * @param {Array} array - Array to iterate over.
- * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
- * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
- * @return {Promise} - Returns a Promise with undefined value.
- */
-export const forEachSeries = async (array, callback, thisArg) => {
-    for (let i = 0; i < array.length; i++) {
-        if (i in array) {
-            await callback.call(thisArg || this, await array[i], i, array);
-        }
-    }
-};
-/**
- * Implements ES5 [`Array#map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) method.<br><br>
- * Creates a new array with the results of calling the provided callback once for each element.<br>
- * Callbacks are run concurrently,
- * and are only invoked for properties of the array that have been initialized (including those initialized with *undefined*), for unassigned ones`callback` is not run.<br>
- * Resultant *Array* is always the same *length* as the original one.
- * @param {Array} array - Array to iterate over.
- * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
- * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
- * @return {Promise} - Returns a Promise with the resultant *Array* as value.
- */
-export const map = async (array, callback, thisArg) => {
-    const promiseArray = [];
-    for (let i = 0; i < array.length; i++) {
-        if (i in array) {
-            promiseArray[i] = Promise.resolve(array[i]).then((currentValue) => {
-                return callback.call(thisArg || this, currentValue, i, array);
-            });
-        }
-    }
-    return Promise.all(promiseArray);
-};
-/**
- * Same functionality as [`map()`](global.html#map), but runs only one callback at a time.
- * @param {Array} array - Array to iterate over.
- * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
- * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
- * @return {Promise} - Returns a Promise with the resultant *Array* as value.
- */
-export const mapSeries = async (array, callback, thisArg) => {
-    const result = [];
-    for (let i = 0; i < array.length; i++) {
-        if (i in array) {
-            result[i] = await callback.call(thisArg || this, await array[i], i, array);
-        }
-    }
-    return result;
-};
-/**
- * Implements ES5 [`Array#find()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find) method.<br><br>
- * Returns the value of the element that satisfies the provided `callback`. The value returned is the one found first.<br>
- * Callbacks are run concurrently, meaning that all the callbacks are going to run even if the returned value is found in one of the first elements of `array`,
- * depending on the async calls you are going to use, consider using instead [`findSeries()`](global.html#findSeries).<br>
- * @param {Array} array - Array to iterate over.
- * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
- * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
- * @return {Promise} - Returns a Promise with the element that passed the test as value, otherwise *undefined*.
- */
-export const find = (array, callback, thisArg) => {
-    return new Promise((resolve, reject) => {
-        if (array.length === 0) {
-            return resolve(undefined);
-        }
-        let counter = 1;
-        for (let i = 0; i < array.length; i++) {
-            const check = (found) => {
-                if (found) {
-                    resolve(array[i]);
-                }
-                else if (counter === array.length) {
-                    resolve(undefined);
-                }
-                counter++;
-            };
-            Promise.resolve(array[i])
-                .then((elem) => callback.call(thisArg || this, elem, i, array))
-                .then(check)
-                .catch(reject);
-        }
-    });
-};
-/**
- * Same functionality as [`find()`](global.html#find), but runs only one callback at a time.
- * @param {Array} array - Array to iterate over.
- * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
- * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
- * @return {Promise} - Returns a Promise with the element that passed the test as value, otherwise *undefined*.
- */
-export const findSeries = async (array, callback, thisArg) => {
-    for (let i = 0; i < array.length; i++) {
-        if (await callback.call(thisArg || this, await array[i], i, array)) {
-            return array[i];
-        }
-    }
-};
-/**
- * Implements ES5 [`Array#findIndex()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex) method.<br><br>
- * Returns the index of the element that satisfies the provided `callback`. The index returned is the one found first.<br>
- * Callbacks are run concurrently, meaning that all the callbacks are going to run even if the returned index is found in one of the first elements of `array`,
- * depending on the async calls you are going to use, consider using instead [`findSeries()`](global.html#findSeries).<br>
- * @param {Array} array - Array to iterate over.
- * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
- * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
- * @return {Promise} - Returns a Promise with the index that passed the test as value, otherwise *-1*.
- */
-export const findIndex = (array, callback, thisArg) => {
-    return new Promise((resolve, reject) => {
-        if (array.length === 0) {
-            return resolve(-1);
-        }
-        let counter = 1;
-        for (let i = 0; i < array.length; i++) {
-            const check = (found) => {
-                if (found) {
-                    resolve(i);
-                }
-                else if (counter === array.length) {
-                    resolve(-1);
-                }
-                counter++;
-            };
-            Promise.resolve(array[i])
-                .then((elem) => callback.call(thisArg || this, elem, i, array))
-                .then(check)
-                .catch(reject);
-        }
-    });
-};
-/**
- * Same functionality as [`findIndex()`](global.html#findIndex), but runs only one callback at a time.
- * @param {Array} array - Array to iterate over.
- * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
- * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
- * @return {Promise} - Returns a Promise with the index that passed the test, otherwise *-1*.
- */
-export const findIndexSeries = async (array, callback, thisArg) => {
-    for (let i = 0; i < array.length; i++) {
-        if (await callback.call(thisArg || this, await array[i], i, array)) {
-            return i;
-        }
-    }
-};
-/**
- * Implements ES5 [`Array#some()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some) method.<br><br>
- * Test if some element in `array` passes the test implemented in `callback`.<br>
- * Callbacks are run concurrently, meaning that all the callbacks are going to run even if some of the first elements pass the test,
- * depending on the async calls you are going to use, consider using instead [`someSeries()`](global.html#someSeries).<br>
- * @param {Array} array - Array to iterate over.
- * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
- * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
- * @return {Promise} - Returns a Promise with *true* as value if some element passed the test, otherwise *false*.
- */
-export const some = (array, callback, thisArg) => {
-    return new Promise((resolve, reject) => {
-        if (array.length === 0) {
-            return resolve(false);
-        }
-        let counter = 1;
-        for (let i = 0; i < array.length; i++) {
-            if (!(i in array)) {
-                counter++;
-                continue;
-            }
-            const check = (found) => {
-                if (found) {
-                    resolve(true);
-                }
-                else if (counter === array.length) {
-                    resolve(false);
-                }
-                counter++;
-            };
-            Promise.resolve(array[i])
-                .then((elem) => callback.call(thisArg || this, elem, i, array))
-                .then(check)
-                .catch(reject);
-        }
-    });
-};
-/**
- * Same functionality as [`some()`](global.html#some), but runs only one callback at a time.
- * @param {Array} array - Array to iterate over.
- * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
- * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
- * @return {Promise} - Returns a Promise with *true* as value if some element passed the test, otherwise *false*.
- */
-export const someSeries = async (array, callback, thisArg) => {
-    for (let i = 0; i < array.length; i++) {
-        if (i in array && await callback.call(thisArg || this, await array[i], i, array)) {
-            return true;
-        }
-    }
-    return false;
-};
-/**
- * Implements ES5 [`Array#every()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every) method.<br><br>
- * Test if all elements in `array` pass the test implemented in `callback`.<br>
- * Callbacks are run concurrently, meaning that all the callbacks are going to run even if any of the first elements do not pass the test,
- * depending on the async calls you are going to use, consider using instead [`everySeries()`](global.html#everySeries).<br>
- * @param {Array} array - Array to iterate over.
- * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
- * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
- * @return {Promise} - Returns a Promise with *true* as value if all elements passed the test, otherwise *false*.
- */
-export const every = (array, callback, thisArg) => {
-    return new Promise((resolve, reject) => {
-        if (array.length === 0) {
-            return resolve(true);
-        }
-        let counter = 1;
-        for (let i = 0; i < array.length; i++) {
-            if (!(i in array)) {
-                counter++;
-                continue;
-            }
-            const check = (found) => {
-                if (!found) {
-                    resolve(false);
-                }
-                else if (counter === array.length) {
-                    resolve(true);
-                }
-                counter++;
-            };
-            Promise.resolve(array[i])
-                .then((elem) => callback.call(thisArg || this, elem, i, array))
-                .then(check)
-                .catch(reject);
-        }
-    });
-};
-/**
- * Same functionality as [`every()`](global.html#every), but runs only one callback at a time.<br><br>
- * @param {Array} array - Array to iterate over.
- * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
- * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
- * @return {Promise} - Returns a Promise with *true* as value if all elements passed the test, otherwise *false*.
- */
-export const everySeries = async (array, callback, thisArg) => {
-    for (let i = 0; i < array.length; i++) {
-        if (i in array && !await callback.call(thisArg || this, await array[i], i, array)) {
-            return false;
-        }
-    }
-    return true;
-};
-/**
- * Implements ES5 [`Array#filter()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) method.<br><br>
- * Creates a new array with the elements that passed the test implemented in `callback`.<br>
- * Callbacks are run concurrently.<br>
- * @param {Array} array - Array to iterate over.
- * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
- * @param {Object} [thisArg] - Value to use as *this* when executing the `callback`.
- * @return {Promise} - Returns a Promise with the resultant filtered *Array* as value.
- */
-export const filter = (array, callback, thisArg) => {
-    /* two loops are necessary in order to do the filtering concurrently
-     * while keeping the order of the elements
-     * (if you find a better way to do it please send a PR!)
-     */
-    return new Promise((resolve, reject) => {
-        const promiseArray = [];
-        for (let i = 0; i < array.length; i++) {
-            if (i in array) {
-                promiseArray[i] = Promise.resolve(array[i]).then((currentValue) => {
-                    return callback.call(thisArg || this, currentValue, i, array);
-                }).catch(reject);
-            }
-        }
-        return Promise.all(promiseArray.map(async (p, i) => {
-            if (await p) {
-                return await array[i];
-            }
-            return undefined;
-        })).then((result) => result.filter((val) => typeof val !== 'undefined')).then(resolve, reject);
-    });
-};
-/**
- * Same functionality as [`filter()`](global.html#filter), but runs only one callback at a time.
- * @param {Array} array - Array to iterate over.
- * @param {Function} callback - Function to apply each item in `array`. Accepts three arguments: `currentValue`, `index` and `array`.
- * @return {Promise} - Returns a Promise with the resultant filtered *Array* as value.
- */
-export const filterSeries = async (array, callback, thisArg) => {
-    const result = [];
-    for (let i = 0; i < array.length; i++) {
-        if (i in array && await callback.call(thisArg || this, await array[i], i, array)) {
-            result.push(await array[i]);
-        }
-    }
-    return result;
-};
-/**
- * Implements ES5 [`Array#reduce()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) method.<br><br>
- * Applies a `callback` against an accumulator and each element in `array`.
- * @param {Array} array - Array to iterate over.
- * @param {Function} callback - Function to apply each item in `array`. Accepts four arguments: `accumulator`, `currentValue`, `currentIndex` and `array`.
- * @param {Object} [initialValue] - Used as first argument to the first call of `callback`.
- * @return {Promise} - Returns a Promise with the resultant value from the reduction.
- */
-export const reduce = async (array, callback, initialValue) => {
-    if (array.length === 0 && initialValue === undefined) {
-        throw TypeError('Reduce of empty array with no initial value');
-    }
-    let i;
-    let previousValue;
-    if (initialValue !== undefined) {
-        previousValue = initialValue;
-        i = 0;
-    }
-    else {
-        previousValue = array[0];
-        i = 1;
-    }
-    for (i; i < array.length; i++) {
-        if (i in array) {
-            previousValue = await callback(await previousValue, await array[i], i, array);
-        }
-    }
-    return previousValue;
-};