@applitools/eyes-cypress 3.28.0 → 3.28.2

package/src/plugin/errorDigest.js

@@ -1,4 +1,4 @@
-'use strict';
+'use strict'
 
 const colors = {
   green: '\x1b[32m',
@@ -6,7 +6,7 @@ const colors = {
   teal: '\x1b[38;5;86m',
   orange: '\x1b[38;5;214m',
   reset: '\x1b[0m',
-};
+}
 
 const formatByStatus = {
   Passed: {
@@ -24,73 +24,65 @@ const formatByStatus = {
     symbol: '\u26A0',
     title: tests => `Diffs detected - ${tests} tests`,
   },
-};
+}
 
 function errorDigest({passed, failed, diffs, logger, isInteractive}) {
-  logger.log('errorDigest: diff errors', diffs);
-  logger.log('errorDigest: test errors', failed);
+  logger.log('errorDigest: diff errors', diffs)
+  logger.log('errorDigest: test errors', failed)
 
-  const testResultsUrl = diffs.length ? colorify(diffs[0].url, 'teal') : '';
-  const testResultsPrefix = testResultsUrl ? 'See details at:' : '';
-  const footer = testResultsUrl
-    ? `\n${indent()}${colorify(testResultsPrefix)} ${testResultsUrl}`
-    : '';
+  const testResultsUrl = diffs.length ? colorify(` ${diffs[0].url} `, 'teal') : '' // the space around the url is for the link to be clickable in the cypress run
+  const testResultsPrefix = testResultsUrl ? 'See details at:' : ''
+  const footer = testResultsUrl ? `\n${indent()}${colorify(testResultsPrefix)}${testResultsUrl}` : ''
   return (
     colorify('Eyes-Cypress detected diffs or errors during execution of visual tests.') +
-    colorify(` ${testResultsPrefix} ${testResultsUrl}`) +
+    colorify(` ${testResultsPrefix}${testResultsUrl}`) +
     testResultsToString(passed, 'Passed') +
     testResultsToString(diffs, 'Unresolved') +
     testResultsToString(failed, 'Failed') +
     footer +
     '\n\n'
-  );
+  )
 
   function testResultsToString(testResultsArr, category) {
-    const {color, title, symbol, chalkFunction} = formatByStatus[category];
+    const {color, title, symbol, chalkFunction} = formatByStatus[category]
     const results = testResultsArr.reduce((acc, testResults) => {
       if (!testResults.isEmpty) {
-        const error = hasError(testResults) ? stringifyError(testResults) : undefined;
-        acc.push(
-          `${colorify(symbol, color)} ${colorify(error || stringifyTestResults(testResults))}`,
-        );
+        const error = hasError(testResults) ? stringifyError(testResults) : undefined
+        acc.push(`${colorify(symbol, color)} ${colorify(error || stringifyTestResults(testResults))}`)
       }
-      return acc;
-    }, []);
+      return acc
+    }, [])
 
-    const coloredTitle = results.length
-      ? colorify(title(results.length), color, chalkFunction)
-      : '';
-    return testResultsSection(coloredTitle, results);
+    const coloredTitle = results.length ? colorify(title(results.length), color, chalkFunction) : ''
+    return testResultsSection(coloredTitle, results)
   }
 
   function colorify(msg, color = 'reset') {
-    return isInteractive ? msg : `${colors[color]}${msg}${colors.reset}`;
+    return isInteractive ? msg : `${colors[color]}${msg}${colors.reset}`
   }
 }
 
 function stringifyTestResults(testResults) {
-  const hostDisplaySize = testResults.hostDisplaySize;
-  const viewport = hostDisplaySize ? `[${hostDisplaySize.width}x${hostDisplaySize.height}]` : '';
-  const testName = `${testResults.name} ${viewport}`;
-  return testName + (testResults.error ? ` : ${testResults.error}` : '');
+  const hostDisplaySize = testResults.hostDisplaySize
+  const viewport = hostDisplaySize ? `[${hostDisplaySize.width}x${hostDisplaySize.height}]` : ''
+  const testName = `${testResults.name} ${viewport}`
+  return testName + (testResults.error ? ` : ${testResults.error}` : '')
 }
 
 function testResultsSection(title, results) {
-  return results.length ? `${indent()}${title}${indent(3)}${results.join(indent(3))}` : '';
+  return results.length ? `${indent()}${title}${indent(3)}${results.join(indent(3))}` : ''
 }
 
 function stringifyError(testResults) {
-  return testResults.error
-    ? stringifyTestResults(testResults)
-    : `[Eyes test not started] : ${testResults}`;
+  return testResults.error ? stringifyTestResults(testResults) : `[Eyes test not started] : ${testResults}`
 }
 
 function indent(spaces = 2) {
-  return `\n   ${'  '.repeat(spaces)}`;
+  return `\n   ${'  '.repeat(spaces)}`
 }
 
 function hasError(testResult) {
-  return testResult.error || testResult instanceof Error;
+  return testResult.error || testResult instanceof Error
 }
 
-module.exports = errorDigest;
+module.exports = errorDigest

package/src/plugin/getErrorsAndDiffs.js

@@ -1,33 +1,33 @@
-'use strict';
+'use strict'
 function getErrorsAndDiffs(testResultsArr) {
   return testResultsArr.reduce(
     ({failed, diffs, passed}, testResults) => {
       if (testResults instanceof Error || testResults.error) {
-        failed.push(testResults);
+        failed.push(testResults)
       } else {
-        const testStatus = testResults.status;
+        const testStatus = testResults.status
         if (testStatus === 'Passed') {
-          passed.push(testResults);
+          passed.push(testResults)
         } else {
           if (testStatus === 'Unresolved') {
             if (testResults.isNew) {
               testResults.error = new Error(
                 `${testResults.name}. Please approve the new baseline at ${testResults.url}`,
-              );
-              failed.push(testResults);
+              )
+              failed.push(testResults)
             } else {
-              diffs.push(testResults);
+              diffs.push(testResults)
             }
           } else if (testStatus === 'Failed') {
-            failed.push(testResults);
+            failed.push(testResults)
           }
         }
       }
 
-      return {failed, diffs, passed};
+      return {failed, diffs, passed}
     },
     {failed: [], diffs: [], passed: []},
-  );
+  )
 }
 
-module.exports = getErrorsAndDiffs;
+module.exports = getErrorsAndDiffs

package/src/plugin/handleTestResults.js

@@ -1,19 +1,19 @@
-const errorDigest = require('./errorDigest');
-const {makeLogger} = require('@applitools/logger');
-const getErrorsAndDiffs = require('./getErrorsAndDiffs');
-const {promisify} = require('util');
-const fs = require('fs');
-const writeFile = promisify(fs.writeFile);
-const {formatters} = require('@applitools/core');
-const {resolve} = require('path');
+const errorDigest = require('./errorDigest')
+const {makeLogger} = require('@applitools/logger')
+const getErrorsAndDiffs = require('./getErrorsAndDiffs')
+const {promisify} = require('util')
+const fs = require('fs')
+const writeFile = promisify(fs.writeFile)
+const {formatters} = require('@applitools/core')
+const {resolve} = require('path')
 
 function printTestResults(testResultsArr) {
   const logger = makeLogger({
     level: testResultsArr.resultConfig.showLogs ? 'info' : 'silent',
     label: 'eyes',
-  });
-  if (!testResultsArr.testResults) return;
-  const {passed, failed, diffs} = getErrorsAndDiffs(testResultsArr.testResults);
+  })
+  if (!testResultsArr.testResults) return
+  const {passed, failed, diffs} = getErrorsAndDiffs(testResultsArr.testResults)
   if ((failed.length || diffs.length) && !!testResultsArr.resultConfig.eyesFailCypressOnDiff) {
     throw new Error(
       errorDigest({
@@ -23,16 +23,13 @@ function printTestResults(testResultsArr) {
         logger,
         isInteractive: !testResultsArr.resultConfig.isTextTerminal,
       }),
-    );
+    )
   }
 }
 function handleBatchResultsFile(results, tapFileConfig) {
-  const fileName = tapFileConfig.tapFileName || `${new Date().toISOString()}-eyes.tap`;
-  const tapFile = resolve(tapFileConfig.tapDirPath, fileName);
-  return writeFile(
-    tapFile,
-    formatters.toHierarchicTAPString(results, {includeSubTests: false, markNewAsPassed: true}),
-  );
+  const fileName = tapFileConfig.tapFileName || `${new Date().toISOString()}-eyes.tap`
+  const tapFile = resolve(tapFileConfig.tapDirPath, fileName)
+  return writeFile(tapFile, formatters.toHierarchicTAPString(results, {includeSubTests: false, markNewAsPassed: true}))
 }
 
-module.exports = {printTestResults, handleBatchResultsFile};
+module.exports = {printTestResults, handleBatchResultsFile}

package/src/plugin/hooks.js

@@ -1,20 +1,20 @@
-'use strict';
-const handleTestResults = require('./handleTestResults');
+'use strict'
+const handleTestResults = require('./handleTestResults')
 
 function makeGlobalRunHooks({closeManager, closeBatches, closeUniversalServer}) {
   return {
     'before:run': ({config}) => {
-      if (!config.isTextTerminal) return;
+      if (!config.isTextTerminal) return
     },
 
     'after:run': async ({config}) => {
       try {
-        if (!config.isTextTerminal) return;
-        const summaries = await closeManager();
+        if (!config.isTextTerminal) return
+        const summaries = await closeManager()
 
-        let testResults;
+        let testResults
         for (const summary of summaries) {
-          testResults = summary.results.map(({testResults}) => testResults);
+          testResults = summary.results.map(({testResults}) => testResults)
         }
         if (!config.appliConfFile.dontCloseBatches) {
           await closeBatches({
@@ -22,20 +22,20 @@ function makeGlobalRunHooks({closeManager, closeBatches, closeUniversalServer})
             serverUrl: config.appliConfFile.serverUrl,
             proxy: config.appliConfFile.proxy,
             apiKey: config.appliConfFile.apiKey,
-          });
+          })
         }
 
         if (config.appliConfFile.tapDirPath) {
           await handleTestResults.handleBatchResultsFile(testResults, {
             tapDirPath: config.appliConfFile.tapDirPath,
             tapFileName: config.appliConfFile.tapFileName,
-          });
+          })
         }
       } finally {
-        await closeUniversalServer();
+        await closeUniversalServer()
       }
     },
-  };
+  }
 }
 
-module.exports = makeGlobalRunHooks;
+module.exports = makeGlobalRunHooks

package/src/plugin/isGlobalHooksSupported.js

@@ -1,14 +1,13 @@
-const CYPRESS_SUPPORTED_VERSION = '6.2.0';
-const CYPRESS_NO_FLAG_VERSION = '6.7.0';
+const CYPRESS_SUPPORTED_VERSION = '6.2.0'
+const CYPRESS_NO_FLAG_VERSION = '6.7.0'
 
 function isGlobalHooksSupported(config) {
-  const {version, experimentalRunEvents} = config;
+  const {version, experimentalRunEvents} = config
 
   return (
     parseFloat(version, 10) >= parseFloat(CYPRESS_NO_FLAG_VERSION, 10) ||
-    (parseFloat(version, 10) >= parseFloat(CYPRESS_SUPPORTED_VERSION, 10) &&
-      !!experimentalRunEvents)
-  );
+    (parseFloat(version, 10) >= parseFloat(CYPRESS_SUPPORTED_VERSION, 10) && !!experimentalRunEvents)
+  )
 }
 
-module.exports = isGlobalHooksSupported;
+module.exports = isGlobalHooksSupported

package/src/plugin/pluginExport.js

@@ -1,99 +1,94 @@
-'use strict';
-const isGlobalHooksSupported = require('./isGlobalHooksSupported');
-const {presult} = require('@applitools/functional-commons');
-const makeGlobalRunHooks = require('./hooks');
+'use strict'
+const isGlobalHooksSupported = require('./isGlobalHooksSupported')
+const {presult} = require('@applitools/functional-commons')
+const makeGlobalRunHooks = require('./hooks')
 
 function makePluginExport({startServer, eyesConfig}) {
   return function pluginExport(pluginModule) {
-    let eyesServer, pluginModuleExports, pluginExportsE2E, pluginExportsComponent;
+    let eyesServer, pluginModuleExports, pluginExportsE2E, pluginExportsComponent
     const pluginExports =
-      pluginModule.exports && pluginModule.exports.default
-        ? pluginModule.exports.default
-        : pluginModule.exports;
+      pluginModule.exports && pluginModule.exports.default ? pluginModule.exports.default : pluginModule.exports
 
     if (pluginExports.component) {
-      pluginExportsComponent = pluginExports.component.setupNodeEvents;
+      pluginExportsComponent = pluginExports.component.setupNodeEvents
     }
     if (pluginExports.e2e) {
-      pluginExportsE2E = pluginExports.e2e.setupNodeEvents;
+      pluginExportsE2E = pluginExports.e2e.setupNodeEvents
     }
     if (!pluginExports.e2e && !pluginExports.component) {
-      pluginModuleExports = pluginExports;
+      pluginModuleExports = pluginExports
     }
 
-    const setupNodeEvents = async function(...args) {
-      const {server, port, closeManager, closeBatches, closeUniversalServer} = await startServer();
-      eyesServer = server;
+    const setupNodeEvents = async function (...args) {
+      const {server, port, closeManager, closeBatches, closeUniversalServer} = await startServer()
+      eyesServer = server
 
-      const globalHooks = makeGlobalRunHooks({closeManager, closeBatches, closeUniversalServer});
+      const globalHooks = makeGlobalRunHooks({closeManager, closeBatches, closeUniversalServer})
 
-      const [origOn, config] = args;
+      const [origOn, config] = args
 
       if (!pluginModuleExports) {
-        pluginModuleExports =
-          config.testingType === 'e2e' ? pluginExportsE2E : pluginExportsComponent;
+        pluginModuleExports = config.testingType === 'e2e' ? pluginExportsE2E : pluginExportsComponent
       }
 
-      const isGlobalHookCalledFromUserHandlerMap = new Map();
-      eyesConfig.eyesIsGlobalHooksSupported = isGlobalHooksSupported(config);
-      let moduleExportsResult = {};
+      const isGlobalHookCalledFromUserHandlerMap = new Map()
+      eyesConfig.eyesIsGlobalHooksSupported = isGlobalHooksSupported(config)
+      let moduleExportsResult = {}
       // in case setupNodeEvents is not defined in cypress.config file
       if (typeof pluginModuleExports === 'function') {
-        moduleExportsResult = await pluginModuleExports(onThatCallsUserDefinedHandler, config);
+        moduleExportsResult = await pluginModuleExports(onThatCallsUserDefinedHandler, config)
       }
       if (eyesConfig.eyesIsGlobalHooksSupported) {
         for (const [eventName, eventHandler] of Object.entries(globalHooks)) {
           if (!isGlobalHookCalledFromUserHandlerMap.get(eventName)) {
-            origOn.call(this, eventName, eventHandler);
+            origOn.call(this, eventName, eventHandler)
           }
         }
       }
 
-      return Object.assign({}, eyesConfig, {eyesPort: port}, moduleExportsResult);
+      return Object.assign({}, eyesConfig, {eyesPort: port}, moduleExportsResult)
 
       // This piece of code exists because at the point of writing, Cypress does not support multiple event handlers:
       // https://github.com/cypress-io/cypress/issues/5240#issuecomment-948277554
       // So we wrap Cypress' `on` function in order to wrap the user-defined handler. This way we can call our own handler
       // in addition to the user's handler
       function onThatCallsUserDefinedHandler(eventName, handler) {
-        const isRunEvent = eventName === 'before:run' || eventName === 'after:run';
-        let handlerToCall = handler;
+        const isRunEvent = eventName === 'before:run' || eventName === 'after:run'
+        let handlerToCall = handler
         if (eyesConfig.eyesIsGlobalHooksSupported && isRunEvent) {
-          handlerToCall = handlerThatCallsUserDefinedHandler;
-          isGlobalHookCalledFromUserHandlerMap.set(eventName, true);
+          handlerToCall = handlerThatCallsUserDefinedHandler
+          isGlobalHookCalledFromUserHandlerMap.set(eventName, true)
         }
-        return origOn.call(this, eventName, handlerToCall);
+        return origOn.call(this, eventName, handlerToCall)
 
         async function handlerThatCallsUserDefinedHandler() {
-          const [err] = await presult(
-            Promise.resolve(globalHooks[eventName].apply(this, arguments)),
-          );
-          await handler.apply(this, arguments);
+          const [err] = await presult(Promise.resolve(globalHooks[eventName].apply(this, arguments)))
+          await handler.apply(this, arguments)
           if (err) {
-            throw err;
+            throw err
           }
         }
       }
-    };
+    }
 
     if (pluginExports.component) {
-      pluginExports.component.setupNodeEvents = setupNodeEvents;
+      pluginExports.component.setupNodeEvents = setupNodeEvents
     }
     if (pluginExports.e2e) {
-      pluginExports.e2e.setupNodeEvents = setupNodeEvents;
+      pluginExports.e2e.setupNodeEvents = setupNodeEvents
     }
     if (!pluginExports.component && !pluginExports.e2e) {
       if (pluginModule.exports.default) {
-        pluginModule.exports.default = setupNodeEvents;
+        pluginModule.exports.default = setupNodeEvents
       } else {
-        pluginModule.exports = setupNodeEvents;
+        pluginModule.exports = setupNodeEvents
       }
     }
 
     return function getCloseServer() {
-      return eyesServer.close();
-    };
-  };
+      return eyesServer.close()
+    }
+  }
 }
 
-module.exports = makePluginExport;
+module.exports = makePluginExport

package/src/plugin/server.js

@@ -1,48 +1,48 @@
-'use strict';
-const connectSocket = require('./webSocket');
-const {makeServerProcess} = require('@applitools/eyes-universal');
-const handleTestResults = require('./handleTestResults');
-const path = require('path');
-const fs = require('fs');
-const semverLt = require('semver/functions/lt');
-const {Server: HttpsServer} = require('https');
-const {Server: WSServer} = require('ws');
-const which = require('which');
+'use strict'
+const connectSocket = require('./webSocket')
+const {makeServerProcess} = require('@applitools/eyes-universal')
+const handleTestResults = require('./handleTestResults')
+const path = require('path')
+const fs = require('fs')
+const semverLt = require('semver/functions/lt')
+const {Server: HttpsServer} = require('https')
+const {Server: WSServer} = require('ws')
+const which = require('which')
 
 function makeStartServer({logger}) {
   return async function startServer() {
-    const key = fs.readFileSync(path.resolve(__dirname, '../pem/server.key'));
-    const cert = fs.readFileSync(path.resolve(__dirname, '../pem/server.cert'));
-    let port;
+    const key = fs.readFileSync(path.resolve(__dirname, '../pem/server.key'))
+    const cert = fs.readFileSync(path.resolve(__dirname, '../pem/server.cert'))
+    let port
 
     const https = new HttpsServer({
       key,
       cert,
-    });
+    })
     await https.listen(0, err => {
       if (err) {
-        logger.log('error starting plugin server', err);
+        logger.log('error starting plugin server', err)
       } else {
-        logger.log(`plugin server running at port: ${https.address().port}`);
-        port = https.address().port;
+        logger.log(`plugin server running at port: ${https.address().port}`)
+        port = https.address().port
       }
-    });
+    })
 
-    const wss = new WSServer({server: https, path: '/eyes', maxPayload: 254 * 1024 * 1024});
+    const wss = new WSServer({server: https, path: '/eyes', maxPayload: 254 * 1024 * 1024})
 
-    wss.on('close', () => https.close());
+    wss.on('close', () => https.close())
 
     const forkOptions = {
       detached: true,
-    };
+    }
 
-    const cypressVersion = require('cypress/package.json').version;
+    const cypressVersion = require('cypress/package.json').version
 
     // `cypress` version below `7.0.0` has an old Electron version which not support async shell process.
     // By passing `execPath` with the node process cwd it will switch the `node` process to be the like the OS have
     // and will not use the unsupported `Cypress Helper.app` with the not supported shell process Electron
     if (semverLt(cypressVersion, '7.0.0')) {
-      forkOptions.execPath = await which('node');
+      forkOptions.execPath = await which('node')
     }
 
     const {port: universalPort, close: closeUniversalServer} = await makeServerProcess({
@@ -51,27 +51,27 @@ function makeStartServer({logger}) {
       forkOptions,
       singleton: false,
       portResolutionMode: 'random',
-    });
+    })
 
-    const managers = [];
-    let socketWithUniversal;
+    const managers = []
+    let socketWithUniversal
 
     wss.on('connection', socketWithClient => {
-      socketWithUniversal = connectSocket(`ws://localhost:${universalPort}/eyes`);
+      socketWithUniversal = connectSocket(`ws://localhost:${universalPort}/eyes`)
 
       socketWithUniversal.setPassthroughListener(message => {
-        logger.log('<== ', message.toString().slice(0, 1000));
-        const {name, payload} = JSON.parse(message);
+        logger.log('<== ', message.toString().slice(0, 1000))
+        const {name, payload} = JSON.parse(message)
         if (name === 'Core.makeManager') {
-          managers.push({manager: payload.result, socketWithUniversal});
+          managers.push({manager: payload.result, socketWithUniversal})
         }
 
-        socketWithClient.send(message.toString());
-      });
+        socketWithClient.send(message.toString())
+      })
 
       socketWithClient.on('message', message => {
-        const msg = JSON.parse(message);
-        logger.log('==> ', message.toString().slice(0, 1000));
+        const msg = JSON.parse(message)
+        logger.log('==> ', message.toString().slice(0, 1000))
         if (msg.name === 'Core.makeSDK') {
           const newMessage = Buffer.from(
             JSON.stringify({
@@ -80,30 +80,27 @@ function makeStartServer({logger}) {
               payload: Object.assign(msg.payload, {cwd: process.cwd()}),
             }),
             'utf-8',
-          );
-          socketWithUniversal.send(newMessage);
+          )
+          socketWithUniversal.send(newMessage)
         } else if (msg.name === 'Test.printTestResults') {
           try {
-            if (
-              msg.payload.resultConfig.tapDirPath &&
-              msg.payload.resultConfig.shouldCreateTapFile
-            ) {
+            if (msg.payload.resultConfig.tapDirPath && msg.payload.resultConfig.shouldCreateTapFile) {
               handleTestResults.handleBatchResultsFile(msg.payload.testResults, {
                 tapFileName: msg.payload.resultConfig.tapFileName,
                 tapDirPath: msg.payload.resultConfig.tapDirPath,
-              });
+              })
             }
             handleTestResults.printTestResults({
               testResults: msg.payload.testResults,
               resultConfig: msg.payload.resultConfig,
-            });
+            })
             socketWithClient.send(
               JSON.stringify({
                 name: 'Test.printTestResults',
                 key: msg.key,
                 payload: {result: 'success'},
               }),
-            );
+            )
           } catch (ex) {
             socketWithClient.send(
               JSON.stringify({
@@ -111,13 +108,13 @@ function makeStartServer({logger}) {
                 key: msg.key,
                 payload: {result: ex.message.toString()},
               }),
-            );
+            )
           }
         } else {
-          socketWithUniversal.send(message);
+          socketWithUniversal.send(message)
         }
-      });
-    });
+      })
+    })
 
     return {
       server: wss,
@@ -125,7 +122,7 @@ function makeStartServer({logger}) {
       closeManager,
       closeBatches,
       closeUniversalServer,
-    };
+    }
 
     function closeManager() {
       return Promise.all(
@@ -135,15 +132,15 @@ function makeStartServer({logger}) {
             throwErr: false,
           }),
         ),
-      );
+      )
     }
     function closeBatches(settings) {
       if (socketWithUniversal)
         return socketWithUniversal.request('Core.closeBatches', {settings}).catch(err => {
-          logger.log('@@@', err);
-        });
+          logger.log('@@@', err)
+        })
     }
-  };
+  }
 }
 
-module.exports = makeStartServer;
+module.exports = makeStartServer

package/src/plugin/startPlugin.js

@@ -1,15 +1,15 @@
-'use strict';
-const makePluginExport = require('./pluginExport');
-const makeConfig = require('./config');
-const makeStartServer = require('./server');
-const {makeLogger} = require('@applitools/logger');
+'use strict'
+const makePluginExport = require('./pluginExport')
+const makeConfig = require('./config')
+const makeStartServer = require('./server')
+const {makeLogger} = require('@applitools/logger')
 
-const {config, eyesConfig} = makeConfig();
-const logger = makeLogger({level: config.showLogs ? 'info' : 'silent', label: 'eyes'});
+const {config, eyesConfig} = makeConfig()
+const logger = makeLogger({level: config.showLogs ? 'info' : 'silent', label: 'eyes'})
 
-const startServer = makeStartServer({logger});
+const startServer = makeStartServer({logger})
 
 module.exports = makePluginExport({
   startServer,
   eyesConfig: Object.assign({}, eyesConfig, {appliConfFile: config}),
-});
+})