codeceptjs 4.0.0-rc.11 → 4.0.0-rc.15

package/lib/listener/mocha.js

@@ -1,10 +1,11 @@
 import event from '../event.js'
+import container from '../container.js'
 
 export default function () {
   let mocha
 
   event.dispatcher.on(event.all.before, () => {
-    mocha = global.container.mocha()
+    mocha = container.mocha()
   })
 
   event.dispatcher.on(event.test.passed, test => {

package/lib/listener/pageobjects.js

@@ -0,0 +1,43 @@
+import event from '../event.js'
+import recorder from '../recorder.js'
+import store from '../store.js'
+import container from '../container.js'
+import { resetBeforeCalledSet, getBeforeCalledSet } from '../container.js'
+
+export default function () {
+  const runAsyncSupportHook = (hook, param, force) => {
+    if (store.dryRun) return
+    const support = container.supportObjects()
+    Object.keys(support).forEach(key => {
+      if (key === 'I') return
+      const obj = support[key]
+      if (!obj || typeof obj !== 'object' || !obj[hook]) return
+      recorder.add(`pageobject ${key}.${hook}()`, () => obj[hook](param), force, false)
+    })
+  }
+
+  event.dispatcher.on(event.test.started, () => {
+    resetBeforeCalledSet()
+  })
+
+  event.dispatcher.on(event.test.after, () => {
+    if (store.dryRun) return
+    const support = container.supportObjects()
+    const called = getBeforeCalledSet()
+    called.forEach(name => {
+      const obj = support[name]
+      if (obj && obj._after) {
+        recorder.add(`pageobject ${name}._after()`, () => obj._after(), true, false)
+      }
+    })
+    recorder.catchWithoutStop(() => {})
+  })
+
+  event.dispatcher.on(event.suite.after, suite => {
+    runAsyncSupportHook('_afterSuite', suite, true)
+  })
+
+  event.dispatcher.on(event.suite.before, suite => {
+    runAsyncSupportHook('_beforeSuite', suite, true)
+  })
+}

package/lib/listener/result.js

@@ -1,11 +1,12 @@
 import event from '../event.js'
+import container from '../container.js'
 
 export default function () {
   event.dispatcher.on(event.hook.failed, err => {
-    global.container.result().addStats({ failedHooks: 1 })
+    container.result().addStats({ failedHooks: 1 })
   })
 
   event.dispatcher.on(event.test.before, test => {
-    global.container.result().addTest(test)
+    container.result().addTest(test)
   })
 }

package/lib/locator.js

@@ -381,9 +381,121 @@ class Locator {
     return new Locator({ xpath })
   }
 
+  /**
+   * Find an element with all of the provided CSS classes (word-exact match).
+   * Accepts variadic class names; all must be present.
+   *
+   * Example:
+   *   locate('button').withClass('btn-primary', 'btn-lg')
+   *
+   * @param {...string} classes
+   * @returns {Locator}
+   */
+  withClass(...classes) {
+    if (!classes.length) return this
+    const predicates = classes.map(c => `contains(concat(' ', normalize-space(@class), ' '), ' ${c} ')`)
+    const xpath = sprintf('%s[%s]', this.toXPath(), predicates.join(' and '))
+    return new Locator({ xpath })
+  }
+
+  /**
+   * Find an element with none of the provided CSS classes.
+   *
+   * Example:
+   *   locate('tr').withoutClass('deleted')
+   *
+   * @param {...string} classes
+   * @returns {Locator}
+   */
+  withoutClass(...classes) {
+    if (!classes.length) return this
+    const predicates = classes.map(c => `not(contains(concat(' ', normalize-space(@class), ' '), ' ${c} '))`)
+    const xpath = sprintf('%s[%s]', this.toXPath(), predicates.join(' and '))
+    return new Locator({ xpath })
+  }
+
+  /**
+   * Find an element that does NOT contain the provided text.
+   * @param {string} text
+   * @returns {Locator}
+   */
+  withoutText(text) {
+    text = xpathLocator.literal(text)
+    const xpath = sprintf('%s[%s]', this.toXPath(), `not(contains(., ${text}))`)
+    return new Locator({ xpath })
+  }
+
+  /**
+   * Find an element that does NOT have any of the provided attribute/value pairs.
+   * @param {Object.<string, string>} attributes
+   * @returns {Locator}
+   */
+  withoutAttr(attributes) {
+    const operands = []
+    for (const attr of Object.keys(attributes)) {
+      operands.push(`not(@${attr} = ${xpathLocator.literal(attributes[attr])})`)
+    }
+    const xpath = sprintf('%s[%s]', this.toXPath(), operands.join(' and '))
+    return new Locator({ xpath })
+  }
+
+  /**
+   * Find an element that has no direct child matching the provided locator.
+   * @param {CodeceptJS.LocatorOrString} locator
+   * @returns {Locator}
+   */
+  withoutChild(locator) {
+    const xpath = sprintf('%s[not(./child::%s)]', this.toXPath(), convertToSubSelector(locator))
+    return new Locator({ xpath })
+  }
+
+  /**
+   * Find an element that has no descendant matching the provided locator.
+   *
+   * Example:
+   *   locate('button').withoutDescendant('svg')
+   *
+   * @param {CodeceptJS.LocatorOrString} locator
+   * @returns {Locator}
+   */
+  withoutDescendant(locator) {
+    const xpath = sprintf('%s[not(./descendant::%s)]', this.toXPath(), convertToSubSelector(locator))
+    return new Locator({ xpath })
+  }
+
+  /**
+   * Append a raw XPath predicate. Escape hatch for expressions not covered by the DSL.
+   * Argument is inserted as-is inside `[ ]`; quoting/escaping is the caller's responsibility.
+   *
+   * Example:
+   *   locate('input').and('@type="text" or @type="email"')
+   *
+   * @param {string} xpathExpression
+   * @returns {Locator}
+   */
+  and(xpathExpression) {
+    const xpath = sprintf('%s[%s]', this.toXPath(), xpathExpression)
+    return new Locator({ xpath })
+  }
+
+  /**
+   * Append a negated raw XPath predicate: `[not(expr)]`.
+   *
+   * Example:
+   *   locate('button').andNot('.//svg')   // button without a descendant svg
+   *
+   * @param {string} xpathExpression
+   * @returns {Locator}
+   */
+  andNot(xpathExpression) {
+    const xpath = sprintf('%s[not(%s)]', this.toXPath(), xpathExpression)
+    return new Locator({ xpath })
+  }
+
   /**
    * @param {String} text
    * @returns {Locator}
+   * @deprecated Use {@link Locator#withClass} for word-exact class matching, or {@link Locator#withAttrContains} for substring matching.
    */
   withClassAttr(text) {
     const xpath = sprintf('%s[%s]', this.toXPath(), `contains(@class, '${text}')`)

package/lib/mocha/cli.js

@@ -8,6 +8,7 @@ import { dirname, join } from 'path'
 import event from '../event.js'
 import AssertionFailedError from '../assert/error.js'
 import output from '../output.js'
+import store from '../store.js'
 import test, { cloneTest } from './test.js'
 import { fixErrorStack } from '../utils/typescript.js'
 
@@ -41,7 +42,7 @@ class Cli extends Base {
     if (opts.verbose) level = 3
     output.level(level)
     output.print(`CodeceptJS v${codeceptVersion} ${output.standWithUkraine()}`)
-    output.print(`Using test root "${global.codecept_dir}"`)
+    output.print(`Using test root "${store.codeceptDir}"`)
 
     const showSteps = level >= 1
 
@@ -213,6 +214,7 @@ class Cli extends Base {
       }
 
       // append step traces
+      const Container = await getContainer()
       this.failures = this.failures.map(test => {
         // we will change the stack trace, so we need to clone the test
         const err = test.err
@@ -275,7 +277,7 @@ class Cli extends Base {
         }
 
         try {
-          const fileMapping = global.container?.tsFileMapping?.()
+          const fileMapping = Container?.tsFileMapping?.()
           if (fileMapping) {
             fixErrorStack(err, fileMapping)
           }

package/lib/mocha/factory.js

@@ -8,6 +8,7 @@ import output from '../output.js'
 import scenarioUiFunction from './ui.js'
 import { initMochaGlobals } from '../globals.js'
 import { fixErrorStack } from '../utils/typescript.js'
+import container from '../container.js'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = fsPath.dirname(__filename)
@@ -35,7 +36,7 @@ class MochaFactory {
           // Handle ECONNREFUSED without dynamic import for now
           err = new Error('Connection refused: ' + err.toString())
         }
-        const fileMapping = global.container?.tsFileMapping?.()
+        const fileMapping = container?.tsFileMapping?.()
         if (fileMapping) {
           fixErrorStack(err, fileMapping)
         }

package/lib/mocha/scenarioConfig.js

@@ -1,4 +1,5 @@
 import { isAsyncFunction } from '../utils.js'
+import store from '../store.js'
 
 /** @class */
 class ScenarioConfig {
@@ -40,7 +41,7 @@ class ScenarioConfig {
    * @returns {this}
    */
   retry(retries) {
-    if (process.env.SCENARIO_ONLY) retries = -retries
+    if (store.scenarioOnly) retries = -retries
     this.test.retries(retries)
     return this
   }

package/lib/mocha/ui.js

@@ -9,13 +9,12 @@ import { HookConfig, AfterSuiteHook, AfterHook, BeforeSuiteHook, BeforeHook } fr
 import { initMochaGlobals } from '../globals.js'
 import common from 'mocha/lib/interfaces/common.js'
 import container from '../container.js'
+import store from '../store.js'
 
 const setContextTranslation = context => {
-  // Try global container first, then local container instance
-  const containerToUse = global.container || container
-  if (!containerToUse) return
+  if (!container) return
 
-  const translation = containerToUse.translation?.() || containerToUse.translation
+  const translation = container.translation?.() || container.translation
   const contexts = translation?.value?.('contexts')
 
   if (contexts) {
@@ -119,7 +118,7 @@ export default function (suite) {
     context.Feature.only = function (title, opts) {
       const reString = `^${escapeRe(`${title}:`)}`
       mocha.grep(new RegExp(reString))
-      process.env.FEATURE_ONLY = true
+      store.featureOnly = true
       return context.Feature(title, opts)
     }
 
@@ -171,7 +170,7 @@ export default function (suite) {
     context.Scenario.only = function (title, opts, fn) {
       const reString = `^${escapeRe(`${suites[0].title}: ${title}`.replace(/( \| {.+})?$/g, ''))}`
       mocha.grep(new RegExp(reString))
-      process.env.SCENARIO_ONLY = true
+      store.scenarioOnly = true
       return addScenario(title, opts, fn)
     }
 

package/lib/plugin/aiTrace.js

@@ -4,6 +4,7 @@ import { mkdirp } from 'mkdirp'
 import path from 'path'
 import { fileURLToPath } from 'url'
 
+import store from '../store.js'
 import Container from '../container.js'
 import recorder from '../recorder.js'
 import event from '../event.js'
@@ -16,7 +17,7 @@ const supportedHelpers = Container.STANDARD_ACTING_HELPERS
 const defaultConfig = {
   deleteSuccessful: false,
   fullPageScreenshots: false,
-  output: global.output_dir,
+  output: store.outputDir,
   captureHTML: true,
   captureARIA: true,
   captureBrowserLogs: true,
@@ -84,7 +85,7 @@ export default function (config) {
   let testFailed = false
   let firstFailedStepSaved = false
 
-  const reportDir = config.output ? path.resolve(global.codecept_dir, config.output) : defaultConfig.output
+  const reportDir = config.output ? path.resolve(store.codeceptDir, config.output) : defaultConfig.output
 
   if (config.captureDebugOutput) {
     const originalDebug = output.debug
@@ -437,7 +438,7 @@ export default function (config) {
     const traceFile = path.join(dir, 'trace.md')
     fs.writeFileSync(traceFile, markdown)
 
-    output.print(`🤖 AI Trace: ${colors.white.bold(`file://${traceFile}`)}`)
+    output.print(`Trace Saved: file://${traceFile}`)
 
     if (!test.artifacts) test.artifacts = {}
     test.artifacts.aiTrace = traceFile

package/lib/plugin/analyze.js

@@ -353,7 +353,7 @@ function serializeError(error) {
     errorMessage +=
       '\n' +
       error.stack
-        .replace(global.codecept_dir || '', '.')
+        .replace(store.codeceptDir || '', '.')
         .split('\n')
         .map(line => line.replace(ansiRegExp(), ''))
         .slice(0, 5)

package/lib/plugin/auth.js

@@ -321,7 +321,7 @@ export default function (config) {
       }
       if (config.saveToFile) {
         output.debug(`Saved user session into file for ${name}`)
-        fs.writeFileSync(path.join(global.output_dir, `${name}_session.json`), JSON.stringify(cookies))
+        fs.writeFileSync(path.join(store.outputDir, `${name}_session.json`), JSON.stringify(cookies))
       }
       store[`${name}_session`] = cookies
     }
@@ -377,7 +377,7 @@ export default function (config) {
       }
 
       if (!config.saveToFile) return
-      const cookieFile = path.join(global.output_dir, `${name}_session.json`)
+      const cookieFile = path.join(store.outputDir, `${name}_session.json`)
 
       if (!fileExists(cookieFile)) {
         return
@@ -412,7 +412,7 @@ export default function (config) {
 
 function loadCookiesFromFile(config) {
   for (const name in config.users) {
-    const fileName = path.join(global.output_dir, `${name}_session.json`)
+    const fileName = path.join(store.outputDir, `${name}_session.json`)
     if (!fileExists(fileName)) continue
     const data = fs.readFileSync(fileName).toString()
     try {

package/lib/plugin/pageInfo.js

@@ -6,6 +6,7 @@ import recorder from '../recorder.js'
 import event from '../event.js'
 import { scanForErrorMessages } from '../html.js'
 import { output } from '../index.js'
+import store from '../store.js'
 import { humanizeString, ucfirst } from '../utils.js'
 import { testToFileName } from '../mocha/test.js'
 const defaultConfig = {
@@ -92,7 +93,7 @@ export default function (config = {}) {
     recorder.add('Save page info', () => {
       test.addNote('pageInfo', pageStateToMarkdown(pageState))
 
-      const pageStateFileName = path.join(global.output_dir, `${testToFileName(test)}.pageInfo.md`)
+      const pageStateFileName = path.join(store.outputDir, `${testToFileName(test)}.pageInfo.md`)
       fs.writeFileSync(pageStateFileName, pageStateToMarkdown(pageState))
       test.artifacts.pageInfo = pageStateFileName
       return pageState

package/lib/plugin/pauseOn.js

@@ -0,0 +1,167 @@
+import event from '../event.js'
+import pause from '../pause.js'
+import recorder from '../recorder.js'
+import Container from '../container.js'
+import output from '../output.js'
+
+const supportedHelpers = Container.STANDARD_ACTING_HELPERS
+
+/**
+ * Pauses test execution in different modes. Unlike `pauseOnFail`, this plugin supports
+ * multiple triggers for pausing and is controlled via CLI arguments.
+ *
+ * Enable it via `-p` option with a mode:
+ *
+ * ```
+ * npx codeceptjs run -p pauseOn:fail
+ * npx codeceptjs run -p pauseOn:step
+ * npx codeceptjs run -p pauseOn:file:tests/login_test.js
+ * npx codeceptjs run -p pauseOn:file:tests/login_test.js:43
+ * npx codeceptjs run -p pauseOn:url:/users/*
+ * ```
+ *
+ * #### Modes
+ *
+ * * **fail** — pause when a step fails (same as `pauseOnFail` plugin)
+ * * **step** — pause before first step, use `next` to advance step-by-step
+ * * **file** — pause when execution reaches a specific file (and optionally line)
+ * * **url** — pause when the browser URL matches a pattern (supports `*` wildcards)
+ *
+ */
+export default function (config = {}) {
+  const args = config._args || []
+  const mode = args[0] || 'fail'
+
+  switch (mode) {
+    case 'fail':
+      return initFailMode()
+    case 'step':
+      return initStepMode()
+    case 'file':
+      return initFileMode(args.slice(1))
+    case 'url':
+      return initUrlMode(args.slice(1))
+    default:
+      output.error(`pauseOn: unknown mode "${mode}". Available: fail, step, file, url`)
+  }
+}
+
+function initFailMode() {
+  let failed = false
+
+  event.dispatcher.on(event.test.started, () => {
+    failed = false
+  })
+
+  event.dispatcher.on(event.step.failed, () => {
+    failed = true
+  })
+
+  event.dispatcher.on(event.test.after, () => {
+    if (failed) pause()
+  })
+}
+
+function initStepMode() {
+  let activated = false
+
+  event.dispatcher.on(event.test.before, () => {
+    if (activated) return
+    activated = true
+    recorder.add('pauseOn:step', () => pause())
+  })
+}
+
+function initFileMode(fileArgs) {
+  if (fileArgs.length === 0) {
+    output.error('pauseOn:file requires a path. Usage: -p pauseOn:file:<path>[:<line>]')
+    return
+  }
+
+  const targetFile = fileArgs[0]
+  const targetLine = fileArgs[1] ? parseInt(fileArgs[1], 10) : null
+  let paused = false
+
+  event.dispatcher.on(event.step.before, (step) => {
+    if (paused) return
+
+    const stepLine = step.line()
+    if (!stepLine) return
+
+    const match = parseStepLine(stepLine)
+    if (!match) return
+
+    const fileMatches = match.file.includes(targetFile) || match.file.endsWith(targetFile)
+    if (!fileMatches) return
+
+    if (targetLine !== null && match.line !== targetLine) return
+
+    paused = true
+    recorder.add('pauseOn:file', () => pause())
+  })
+}
+
+function initUrlMode(urlArgs) {
+  if (urlArgs.length === 0) {
+    output.error('pauseOn:url requires a pattern. Usage: -p pauseOn:url:<pattern>')
+    return
+  }
+
+  const urlPattern = urlArgs.join(':')
+
+  const helpers = Container.helpers()
+  let helper = null
+  for (const helperName of supportedHelpers) {
+    if (Object.keys(helpers).indexOf(helperName) > -1) {
+      helper = helpers[helperName]
+    }
+  }
+
+  if (!helper) {
+    output.error('pauseOn:url requires a browser helper (Playwright, WebDriver, Puppeteer, Appium)')
+    return
+  }
+
+  const regex = patternToRegex(urlPattern)
+  let paused = false
+
+  event.dispatcher.on(event.step.after, () => {
+    if (paused) return
+
+    recorder.add('pauseOn:url check', async () => {
+      if (paused) return
+      try {
+        const currentUrl = await helper.grabCurrentUrl()
+        if (regex.test(currentUrl)) {
+          paused = true
+          return pause()
+        }
+      } catch (err) {
+        // page may not be loaded yet
+      }
+    })
+  })
+}
+
+function parseStepLine(stepLine) {
+  let line = stepLine.trim()
+  if (line.startsWith('at ')) line = line.substring(3).trim()
+
+  const lastColon = line.lastIndexOf(':')
+  if (lastColon < 0) return null
+  const secondLastColon = line.lastIndexOf(':', lastColon - 1)
+  if (secondLastColon < 0) return null
+
+  const file = line.substring(0, secondLastColon)
+  const lineNum = parseInt(line.substring(secondLastColon + 1, lastColon), 10)
+
+  if (isNaN(lineNum)) return null
+
+  return { file, line: lineNum }
+}
+
+function patternToRegex(pattern) {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&')
+  const regexStr = escaped.replace(/\*/g, '.*')
+  return new RegExp(regexStr)
+}

package/lib/plugin/screenshotOnFail.js

@@ -8,6 +8,7 @@ import recorder from '../recorder.js'
 import event from '../event.js'
 
 import output from '../output.js'
+import store from '../store.js'
 
 import { fileExists } from '../utils.js'
 import Codeceptjs from '../index.js'
@@ -94,7 +95,7 @@ export default function (config) {
         } else {
           fileName = `${testToFileName(test, { suffix: '', unique: false })}.failed.png`
         }
-        const quietMode = !('output_dir' in global) || !global.output_dir
+        const quietMode = !store.outputDir
         if (!quietMode) {
           output.plugin('screenshotOnFail', 'Test failed, try to save a screenshot')
         }
@@ -139,9 +140,7 @@ export default function (config) {
           await Promise.race([screenshotPromise, timeoutPromise])
 
           if (!test.artifacts) test.artifacts = {}
-          // Some unit tests may not define global.output_dir; avoid throwing when it is undefined
-          // Detect output directory safely (may not be initialized in narrow unit tests)
-          const baseOutputDir = 'output_dir' in global && typeof global.output_dir === 'string' && global.output_dir ? global.output_dir : null
+          const baseOutputDir = store.outputDir || null
           if (baseOutputDir) {
             test.artifacts.screenshot = path.join(baseOutputDir, fileName)
             if (Container.mocha().options.reporterOptions['mocha-junit-reporter'] && Container.mocha().options.reporterOptions['mocha-junit-reporter'].options.attachments) {

package/lib/plugin/stepByStepReport.js

@@ -4,8 +4,9 @@ import figures from 'figures'
 import fs from 'fs'
 import { mkdirp } from 'mkdirp'
 import path from 'path'
-import cheerio from 'cheerio'
+import * as cheerio from 'cheerio'
 
+import store from '../store.js'
 import Container from '../container.js'
 import recorder from '../recorder.js'
 import event from '../event.js'
@@ -19,7 +20,7 @@ const defaultConfig = {
   animateSlides: true,
   ignoreSteps: [],
   fullPageScreenshots: false,
-  output: global.output_dir,
+  output: store.outputDir,
   screenshotsForAllureReport: false,
   disableScreenshotOnFail: true,
 }
@@ -87,7 +88,7 @@ export default function (config) {
 
   const recordedTests = {}
   const pad = '0000'
-  const reportDir = config.output ? path.resolve(global.codecept_dir, config.output) : defaultConfig.output
+  const reportDir = config.output ? path.resolve(store.codeceptDir, config.output) : defaultConfig.output
 
   event.dispatcher.on(event.suite.before, suite => {
     stepNum = -1
@@ -198,7 +199,7 @@ export default function (config) {
     // Ignore steps from BeforeSuite function
     if (scenarioFailed && config.disableScreenshotOnFail) return
     if (step.metaStep && step.metaStep.name === 'BeforeSuite') return
-    if (!step.test) return // Ignore steps from AfterSuite
+    if (!currentTest) return // Ignore steps from AfterSuite
 
     const fileName = `${pad.substring(0, pad.length - stepNum.toString().length) + stepNum.toString()}.png`
     if (step.status === 'failed') {

package/lib/rerun.js

@@ -1,4 +1,5 @@
 import fsPath from 'path'
+import store from './store.js'
 import container from './container.js'
 import event from './event.js'
 import BaseCodecept from './codecept.js'
@@ -29,7 +30,7 @@ class CodeceptRerunner extends BaseCodecept {
         let filesToRun = this.testFiles
         if (test) {
           if (!fsPath.isAbsolute(test)) {
-            test = fsPath.join(global.codecept_dir, test)
+            test = fsPath.join(store.codeceptDir, test)
           }
           filesToRun = this.testFiles.filter(t => fsPath.basename(t, '.js') === test || t === test)
         }

package/lib/result.js

@@ -1,6 +1,7 @@
 import fs from 'fs'
 import path from 'path'
 import { serializeTest } from './mocha/test.js'
+import store from './store.js'
 
 /**
  * @typedef {Object} Stats Statistics for a test result.
@@ -212,7 +213,7 @@ class Result {
    */
   save(fileName) {
     if (!fileName) fileName = 'result.json'
-    fs.writeFileSync(path.join(global.output_dir, fileName), JSON.stringify(this.simplify(), null, 2))
+    fs.writeFileSync(path.join(store.outputDir, fileName), JSON.stringify(this.simplify(), null, 2))
   }
 
   /**

package/lib/step/base.js

@@ -3,6 +3,7 @@ import Secret from '../secret.js'
 import { getCurrentTimeout } from '../timeout.js'
 import { ucfirst, humanizeString, serializeError } from '../utils.js'
 import recordStep from './record.js'
+import store from '../store.js'
 
 const STACK_LINE = 5
 
@@ -148,11 +149,11 @@ class Step {
     const lines = this.stack.split('\n')
     if (lines[STACK_LINE]) {
       let line = lines[STACK_LINE].trim()
-        .replace(global.codecept_dir || '', '.')
+        .replace(store.codeceptDir || '', '.')
         .trim()
 
       // Map .temp.mjs back to original .ts files using container's tsFileMapping
-      const fileMapping = global.container?.tsFileMapping?.()
+      const fileMapping = store.tsFileMapping
       if (line.includes('.temp.mjs') && fileMapping) {
         for (const [tsFile, mjsFile] of fileMapping.entries()) {
           if (line.includes(mjsFile)) {