codeceptjs 4.0.0-beta.9.esm-aria → 4.0.0-rc.10

package/lib/step/meta.js

@@ -58,17 +58,24 @@ class MetaStep extends Step {
     this.status = 'queued'
     this.setArguments(Array.from(arguments).slice(1))
     let result
+    let hasChildSteps = false
 
     const registerStep = step => {
       this.setMetaStep(null)
       step.setMetaStep(this)
+      hasChildSteps = true
     }
     event.dispatcher.prependListener(event.step.before, registerStep)
+
+    // Start timing
+    this.startTime = Date.now()
+
     // Handle async and sync methods.
     if (fn.constructor.name === 'AsyncFunction') {
       result = fn
         .apply(this.context, this.args)
         .then(result => {
+          this.setStatus('success')
           return result
         })
         .catch(error => {
@@ -78,17 +85,27 @@ class MetaStep extends Step {
         .finally(() => {
           this.endTime = Date.now()
           event.dispatcher.removeListener(event.step.before, registerStep)
+          // Only emit events if no child steps were registered
+          if (!hasChildSteps) {
+            event.emit(event.step.started, this)
+            event.emit(event.step.finished, this)
+          }
         })
     } else {
       try {
-        this.startTime = Date.now()
         result = fn.apply(this.context, this.args)
+        this.setStatus('success')
       } catch (error) {
         this.setStatus('failed')
         throw error
       } finally {
         this.endTime = Date.now()
         event.dispatcher.removeListener(event.step.before, registerStep)
+        // Only emit events if no child steps were registered
+        if (!hasChildSteps) {
+          event.emit(event.step.started, this)
+          event.emit(event.step.finished, this)
+        }
       }
     }
 

package/lib/step/record.js

@@ -5,12 +5,13 @@ import output from '../output.js'
 import store from '../store.js'
 import { TIMEOUT_ORDER } from '../timeout.js'
 import retryStep from './retry.js'
+import { fixErrorStack } from '../utils/typescript.js'
 function recordStep(step, args) {
   step.status = 'queued'
 
   // apply step configuration
   const lastArg = args[args.length - 1]
-  if (lastArg instanceof StepConfig) {
+  if (StepConfig.isStepConfig(lastArg)) {
     const stepConfig = args.pop()
     const { opts, timeout, retry } = stepConfig.getConfig()
 
@@ -60,6 +61,13 @@ function recordStep(step, args) {
   recorder.catch(err => {
     step.status = 'failed'
     step.endTime = +Date.now()
+    
+    // Fix error stack to point to original .ts files (lazy import to avoid circular dependency)
+    const fileMapping = global.container?.tsFileMapping?.()
+    if (fileMapping) {
+      fixErrorStack(err, fileMapping)
+    }
+    
     event.emit(event.step.failed, step, err)
     event.emit(event.step.finished, step)
     throw err

package/lib/utils/loaderCheck.js

@@ -0,0 +1,162 @@
+/**
+ * Utilities for checking TypeScript loader availability
+ */
+
+/**
+ * Check if a TypeScript loader is available for test files
+ * Note: This checks if loaders are in the require array, not if packages are installed
+ * Package installation is checked when actually requiring modules
+ * @param {string[]} requiredModules - Array of required modules from config
+ * @returns {boolean}
+ */
+export function checkTypeScriptLoader(requiredModules = []) {
+  // Check if a loader is configured in the require array
+  return (
+    requiredModules.includes('tsx/esm') ||
+    requiredModules.includes('tsx/cjs') ||
+    requiredModules.includes('tsx') ||
+    requiredModules.includes('ts-node/esm') ||
+    requiredModules.includes('ts-node/register') ||
+    requiredModules.includes('ts-node')
+  )
+}
+
+/**
+ * Generate helpful error message if .ts tests found but no loader configured
+ * @param {string[]} testFiles - Array of test file paths
+ * @returns {string|null} Error message or null if no TypeScript files
+ */
+export function getTypeScriptLoaderError(testFiles) {
+  const tsFiles = testFiles.filter(f => f.endsWith('.ts'))
+
+  if (tsFiles.length === 0) return null
+
+  return `
+╔═════════════════════════════════════════════════════════════════════════════╗
+║                                                                             ║
+║  ⚠️  TypeScript Test Files Detected but No Loader Configured                ║
+║                                                                             ║
+╚═════════════════════════════════════════════════════════════════════════════╝
+
+Found ${tsFiles.length} TypeScript test file(s) but no TypeScript loader is configured.
+
+CodeceptJS 4.x uses ES Modules (ESM) and requires a loader to run TypeScript tests.
+
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ Option 1: tsx (Recommended - Fast, Zero Config)                            │
+└─────────────────────────────────────────────────────────────────────────────┘
+
+  Installation:
+    npm install --save-dev tsx
+
+  Configuration:
+    Add to your codecept.conf.ts or codecept.conf.js:
+
+    export const config = {
+      tests: './**/*_test.ts',
+      require: ['tsx/cjs'],  // ← Add this line
+      helpers: { /* ... */ }
+    }
+
+  Why tsx?
+    ⚡ Fast: Built on esbuild
+    🎯 Zero config: No tsconfig.json required
+    ✅ Works with Mocha: Uses CommonJS hooks
+    ✅ Complete: Handles all TypeScript features
+
+┌─────────────────────────────────────────────────────────────────────────────┐
+│ Option 2: ts-node/esm (Not Recommended - Has Module Resolution Issues)     │
+└─────────────────────────────────────────────────────────────────────────────┘
+
+  ⚠️  ts-node/esm has significant limitations and is not recommended:
+      - Doesn't work with "type": "module" in package.json
+      - Module resolution doesn't work like standard TypeScript ESM
+      - Import statements must use explicit file paths
+  
+  We strongly recommend using tsx/cjs instead.
+  
+  If you still want to use ts-node/esm:
+
+  Installation:
+    npm install --save-dev ts-node
+
+  Configuration:
+    1. Add to your codecept.conf.ts:
+       require: ['ts-node/esm']
+
+    2. Create tsconfig.json:
+       {
+         "compilerOptions": {
+           "module": "ESNext",
+           "target": "ES2022",
+           "moduleResolution": "node",
+           "esModuleInterop": true
+         },
+         "ts-node": {
+           "esm": true
+         }
+       }
+
+    3. Do NOT use "type": "module" in package.json
+
+📚 Documentation: https://codecept.io/typescript
+
+Note: TypeScript config files (codecept.conf.ts) and helpers are automatically
+      transpiled. Only test files require a loader to be configured.
+`
+}
+
+/**
+ * Get warning message if ts-node/esm is being used
+ * @param {string[]} requiredModules - Array of required modules from config
+ * @returns {string|null} Warning message or null
+ */
+export function getTSNodeESMWarning(requiredModules = []) {
+  if (!requiredModules.includes('ts-node/esm')) {
+    return null
+  }
+
+  return `
+⚠️  Warning: ts-node/esm with "module": "esnext" requires explicit file extensions in all imports.
+
+This is a known limitation. Use tsx/cjs instead to write imports without extensions.
+
+Examples:
+
+  ❌ Incorrect (will fail):
+     import loginPage from "./pages/Login";
+
+  ✅ Correct (must include .ts extension):
+     import loginPage from "./pages/Login.ts";
+
+📚 Documentation: https://codecept.io/typescript
+
+`
+}
+
+/**
+ * Check if user is trying to run TypeScript tests without proper loader
+ * @param {string[]} testFiles - Array of test file paths
+ * @param {string[]} requiredModules - Array of required modules from config
+ * @returns {{hasError: boolean, message: string|null}}
+ */
+export function validateTypeScriptSetup(testFiles, requiredModules = []) {
+  const tsFiles = testFiles.filter(f => f.endsWith('.ts'))
+
+  if (tsFiles.length === 0) {
+    // No TypeScript test files, all good
+    return { hasError: false, message: null }
+  }
+
+  // Check if a loader is configured in the require array
+  const hasLoader = checkTypeScriptLoader(requiredModules)
+
+  if (hasLoader) {
+    // Loader configured, all good (package will be checked when requireModules runs)
+    return { hasError: false, message: null }
+  }
+
+  // No loader configured and TypeScript tests exist
+  const message = getTypeScriptLoaderError(testFiles)
+  return { hasError: true, message }
+}

package/lib/utils/typescript.js

@@ -0,0 +1,449 @@
+import fs from 'fs'
+import path from 'path'
+import { pathToFileURL } from 'url'
+
+/**
+ * Load tsconfig.json if it exists
+ * @param {string} tsConfigPath - Path to tsconfig.json
+ * @returns {object|null} - Parsed tsconfig or null
+ */
+function loadTsConfig(tsConfigPath) {
+  if (!fs.existsSync(tsConfigPath)) {
+    return null
+  }
+
+  try {
+    const tsConfigContent = fs.readFileSync(tsConfigPath, 'utf8')
+    return JSON.parse(tsConfigContent)
+  } catch (err) {
+    return null
+  }
+}
+
+/**
+ * Resolve TypeScript path alias to actual file path
+ * @param {string} importPath - Import path with alias (e.g., '#config/urls')
+ * @param {object} tsConfig - Parsed tsconfig.json
+ * @param {string} configDir - Directory containing tsconfig.json
+ * @returns {string|null} - Resolved file path or null if not an alias
+ */
+function resolveTsPathAlias(importPath, tsConfig, configDir) {
+  if (!tsConfig || !tsConfig.compilerOptions || !tsConfig.compilerOptions.paths) {
+    return null
+  }
+
+  const paths = tsConfig.compilerOptions.paths
+
+  for (const [pattern, targets] of Object.entries(paths)) {
+    if (!targets || targets.length === 0) {
+      continue
+    }
+
+    const patternRegex = new RegExp(
+      '^' + pattern.replace(/\*/g, '(.*)') + '$'
+    )
+    const match = importPath.match(patternRegex)
+
+    if (match) {
+      const wildcard = match[1] || ''
+      const target = targets[0]
+      const resolvedTarget = target.replace(/\*/g, wildcard)
+
+      return path.resolve(configDir, resolvedTarget)
+    }
+  }
+
+  return null
+}
+
+/**
+ * Transpile TypeScript files to ES modules with CommonJS shim support
+ * Handles recursive transpilation of imported TypeScript files
+ *
+ * @param {string} mainFilePath - Path to the main TypeScript file to transpile
+ * @param {object} typescript - TypeScript compiler instance
+ * @returns {Promise<{tempFile: string, allTempFiles: string[], fileMapping: any}>} - Main temp file and all temp files created
+ */
+export async function transpileTypeScript(mainFilePath, typescript) {
+  const { transpile } = typescript
+
+  /**
+   * Transpile a single TypeScript file to JavaScript
+   * Injects CommonJS shims (require, module, exports, __dirname, __filename) as needed
+   */
+  const transpileTS = (filePath) => {
+    const tsContent = fs.readFileSync(filePath, 'utf8')
+
+    // Transpile TypeScript to JavaScript with ES module output
+    let jsContent = transpile(tsContent, {
+      module: 99, // ModuleKind.ESNext
+      target: 99, // ScriptTarget.ESNext
+      esModuleInterop: true,
+      allowSyntheticDefaultImports: true,
+      lib: ['lib.esnext.d.ts'], // Enable latest features including top-level await
+      suppressOutputPathCheck: true,
+      skipLibCheck: true,
+    })
+
+    // Check if the code uses CommonJS globals
+    const usesCommonJSGlobals = /__dirname|__filename/.test(jsContent)
+    const usesRequire = /\brequire\s*\(/.test(jsContent)
+    const usesModuleExports = /\b(module\.exports|exports\.)/.test(jsContent)
+
+    if (usesCommonJSGlobals || usesRequire || usesModuleExports) {
+      // Inject ESM equivalents at the top of the file
+      let esmGlobals = ''
+
+      if (usesRequire || usesModuleExports) {
+        // IMPORTANT: Use the original .ts file path as the base for require()
+        // This ensures dynamic require() calls work with relative paths from the original file location
+        const originalFileUrl = `file://${filePath.replace(/\\/g, '/')}`
+        esmGlobals += `import { createRequire } from 'module';
+import { extname as __extname } from 'path';
+const __baseRequire = createRequire('${originalFileUrl}');
+
+// Wrap require to auto-resolve extensions (mimics CommonJS behavior)
+const require = (id) => {
+  try {
+    return __baseRequire(id);
+  } catch (err) {
+    // If module not found and it's a relative/absolute path without extension, try common extensions
+    if (err.code === 'MODULE_NOT_FOUND' && (id.startsWith('./') || id.startsWith('../') || id.startsWith('/'))) {
+      const ext = __extname(id);
+      // Only treat known file extensions as real extensions (so names like .TEST don't block probing)
+      const __knownExts = ['.js', '.cjs', '.mjs', '.json', '.node'];
+      const hasKnownExt = ext && __knownExts.includes(ext.toLowerCase());
+      if (!hasKnownExt) {
+        // Try common extensions in order: .js, .cjs, .json, .node
+        // Note: .ts files cannot be required - they need transpilation first
+        const extensions = ['.js', '.cjs', '.json', '.node'];
+        for (const testExt of extensions) {
+          try {
+            return __baseRequire(id + testExt);
+          } catch (e) {
+            // Continue to next extension
+          }
+        }
+      }
+    }
+    // Re-throw original error if all attempts failed
+    throw err;
+  }
+};
+
+const module = { exports: {} };
+const exports = module.exports;
+
+`
+      }
+
+      if (usesCommonJSGlobals) {
+        // For __dirname and __filename, also use the original file path
+        const originalFileUrl = `file://${filePath.replace(/\\/g, '/')}`
+        esmGlobals += `import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __dirname_fn } from 'path';
+const __filename = '${filePath.replace(/\\/g, '/')}';
+const __dirname = __dirname_fn(__filename);
+
+`
+      }
+
+      jsContent = esmGlobals + jsContent
+
+      // If module.exports is used, we need to export it as default
+      if (usesModuleExports) {
+        jsContent += `\nexport default module.exports;\n`
+      }
+    }
+
+    return jsContent
+  }
+
+  // Create a map to track transpiled files
+  const transpiledFiles = new Map()
+  const baseDir = path.dirname(mainFilePath)
+
+  // Try to find tsconfig.json by walking up the directory tree
+  let tsConfigPath = path.join(baseDir, 'tsconfig.json')
+  let configDir = baseDir
+  let searchDir = baseDir
+
+  while (!fs.existsSync(tsConfigPath) && searchDir !== path.dirname(searchDir)) {
+    searchDir = path.dirname(searchDir)
+    tsConfigPath = path.join(searchDir, 'tsconfig.json')
+    if (fs.existsSync(tsConfigPath)) {
+      configDir = searchDir
+      break
+    }
+  }
+
+  const tsConfig = loadTsConfig(tsConfigPath)
+
+  // Recursive function to transpile a file and all its TypeScript dependencies
+  const transpileFileAndDeps = (filePath) => {
+    // Already transpiled, skip
+    if (transpiledFiles.has(filePath)) {
+      return
+    }
+
+    // Transpile this file
+    let jsContent = transpileTS(filePath)
+
+    // Find all TypeScript imports in this file (both ESM imports and require() calls)
+    const importRegex = /from\s+['"]([^'"]+?)['"]/g
+    const requireRegex = /require\s*\(\s*['"]([^'"]+?)['"]\s*\)/g
+    let match
+    const imports = []
+
+    while ((match = importRegex.exec(jsContent)) !== null) {
+      imports.push({ path: match[1], type: 'import' })
+    }
+
+    while ((match = requireRegex.exec(jsContent)) !== null) {
+      imports.push({ path: match[1], type: 'require' })
+    }
+
+    // Get the base directory for this file
+    const fileBaseDir = path.dirname(filePath)
+
+    // Recursively transpile each imported TypeScript file
+    for (const { path: importPath } of imports) {
+      let importedPath = importPath
+
+      // Check if this is a path alias
+      const resolvedAlias = resolveTsPathAlias(importPath, tsConfig, configDir)
+      if (resolvedAlias) {
+        importedPath = resolvedAlias
+      } else if (importPath.startsWith('.')) {
+        importedPath = path.resolve(fileBaseDir, importPath)
+      } else {
+        continue
+      }
+
+      // Handle .js extensions that might actually be .ts files
+      if (importedPath.endsWith('.js')) {
+        const tsVersion = importedPath.replace(/\.js$/, '.ts')
+        if (fs.existsSync(tsVersion)) {
+          importedPath = tsVersion
+        }
+      }
+
+      // Check for standard module extensions to determine if we should try adding .ts
+      const ext = path.extname(importedPath)
+      const standardExtensions = ['.js', '.mjs', '.cjs', '.json', '.node']
+      const hasStandardExtension = standardExtensions.includes(ext.toLowerCase())
+
+      // If it doesn't end with .ts and doesn't have a standard extension, try adding .ts
+      if (!importedPath.endsWith('.ts') && !hasStandardExtension) {
+        const tsPath = importedPath + '.ts'
+        if (fs.existsSync(tsPath)) {
+          importedPath = tsPath
+        } else {
+          // Try index.ts for directory imports
+          const indexTsPath = path.join(importedPath, 'index.ts')
+          if (fs.existsSync(indexTsPath)) {
+            importedPath = indexTsPath
+          } else {
+            // Try .js extension as well
+            const jsPath = importedPath + '.js'
+            if (fs.existsSync(jsPath)) {
+              // Skip .js files, they don't need transpilation
+              continue
+            }
+          }
+        }
+      }
+
+      // If it's a TypeScript file, recursively transpile it and its dependencies
+      if (importedPath.endsWith('.ts') && fs.existsSync(importedPath)) {
+        transpileFileAndDeps(importedPath)
+      }
+    }
+
+    // After all dependencies are transpiled, rewrite imports in this file
+    jsContent = jsContent.replace(
+      /from\s+['"]([^'"]+?)['"]/g,
+      (match, importPath) => {
+        let resolvedPath = importPath
+        const originalExt = path.extname(importPath)
+
+        // Check if this is a path alias
+        const resolvedAlias = resolveTsPathAlias(importPath, tsConfig, configDir)
+        if (resolvedAlias) {
+          resolvedPath = resolvedAlias
+        } else if (importPath.startsWith('.')) {
+          resolvedPath = path.resolve(fileBaseDir, importPath)
+        } else {
+          return match
+        }
+
+        // If resolved path is a directory, try index.ts
+        if (fs.existsSync(resolvedPath) && fs.statSync(resolvedPath).isDirectory()) {
+          const indexPath = path.join(resolvedPath, 'index.ts')
+          if (fs.existsSync(indexPath) && transpiledFiles.has(indexPath)) {
+            const tempFile = transpiledFiles.get(indexPath)
+            const relPath = path.relative(fileBaseDir, tempFile).replace(/\\/g, '/')
+            if (!relPath.startsWith('.')) {
+              return `from './${relPath}'`
+            }
+            return `from '${relPath}'`
+          }
+        }
+
+        // Handle .js extension that might be .ts
+        if (resolvedPath.endsWith('.js')) {
+          const tsVersion = resolvedPath.replace(/\.js$/, '.ts')
+          if (transpiledFiles.has(tsVersion)) {
+            const tempFile = transpiledFiles.get(tsVersion)
+            const relPath = path.relative(fileBaseDir, tempFile).replace(/\\/g, '/')
+            if (!relPath.startsWith('.')) {
+              return `from './${relPath}'`
+            }
+            return `from '${relPath}'`
+          }
+          return match
+        }
+
+        // Try with .ts extension
+        const tsPath = resolvedPath.endsWith('.ts') ? resolvedPath : resolvedPath + '.ts'
+
+        // If we transpiled this file, use the temp file
+        if (transpiledFiles.has(tsPath)) {
+          const tempFile = transpiledFiles.get(tsPath)
+          const relPath = path.relative(fileBaseDir, tempFile).replace(/\\/g, '/')
+          if (!relPath.startsWith('.')) {
+            return `from './${relPath}'`
+          }
+          return `from '${relPath}'`
+        }
+
+        // Try index.ts for directory imports
+        const indexTsPath = path.join(resolvedPath, 'index.ts')
+        if (transpiledFiles.has(indexTsPath)) {
+          const tempFile = transpiledFiles.get(indexTsPath)
+          const relPath = path.relative(fileBaseDir, tempFile).replace(/\\/g, '/')
+          if (!relPath.startsWith('.')) {
+            return `from './${relPath}'`
+          }
+          return `from '${relPath}'`
+        }
+
+        // If the import doesn't have a standard module extension, add .js for ESM compatibility
+        const standardExtensions = ['.js', '.mjs', '.cjs', '.json', '.node']
+        const hasStandardExtension = standardExtensions.includes(originalExt.toLowerCase())
+
+        if (!hasStandardExtension) {
+          return match.replace(importPath, importPath + '.js')
+        }
+
+        return match
+      }
+    )
+
+    // Also rewrite require() calls to point to transpiled TypeScript files
+    jsContent = jsContent.replace(
+      /require\s*\(\s*['"]([^'"]+?)['"]\s*\)/g,
+      (match, requirePath) => {
+        let resolvedPath = requirePath
+
+        // Check if this is a path alias
+        const resolvedAlias = resolveTsPathAlias(requirePath, tsConfig, configDir)
+        if (resolvedAlias) {
+          resolvedPath = resolvedAlias
+        } else if (requirePath.startsWith('.')) {
+          resolvedPath = path.resolve(fileBaseDir, requirePath)
+        } else {
+          return match
+        }
+
+        // Handle .js extension that might be .ts
+        if (resolvedPath.endsWith('.js')) {
+          const tsVersion = resolvedPath.replace(/\.js$/, '.ts')
+          if (transpiledFiles.has(tsVersion)) {
+            const tempFile = transpiledFiles.get(tsVersion)
+            const relPath = path.relative(fileBaseDir, tempFile).replace(/\\/g, '/')
+            const finalPath = relPath.startsWith('.') ? relPath : './' + relPath
+            return `require('${finalPath}')`
+          }
+          return match
+        }
+
+        // Try with .ts extension
+        const tsPath = resolvedPath.endsWith('.ts') ? resolvedPath : resolvedPath + '.ts'
+
+        // If we transpiled this file, use the temp file
+        if (transpiledFiles.has(tsPath)) {
+          const tempFile = transpiledFiles.get(tsPath)
+          const relPath = path.relative(fileBaseDir, tempFile).replace(/\\/g, '/')
+          const finalPath = relPath.startsWith('.') ? relPath : './' + relPath
+          return `require('${finalPath}')`
+        }
+
+        // Otherwise, keep the require as-is
+        return match
+      }
+    )
+
+    // Write the transpiled file with updated imports
+    const tempFile = filePath.replace(/\.ts$/, '.temp.mjs')
+    fs.writeFileSync(tempFile, jsContent)
+    transpiledFiles.set(filePath, tempFile)
+  }
+
+  // Start recursive transpilation from the main file
+  transpileFileAndDeps(mainFilePath)
+
+  // Get the main transpiled file
+  const tempJsFile = transpiledFiles.get(mainFilePath)
+
+  // Convert to file:// URL for dynamic import() (required on Windows)
+  const tempFileUrl = pathToFileURL(tempJsFile).href
+
+  // Store all temp files for cleanup (keep as paths, not URLs)
+  const allTempFiles = Array.from(transpiledFiles.values())
+
+  return { tempFile: tempFileUrl, allTempFiles, fileMapping: transpiledFiles }
+}
+
+/**
+ * Map error stack traces from temp .mjs files back to original .ts files
+ * @param {Error} error - The error object to fix
+ * @param {Map<string, string>} fileMapping - Map of original .ts files to temp .mjs files
+ * @returns {Error} - Error with fixed stack trace
+ */
+export function fixErrorStack(error, fileMapping) {
+  if (!error.stack || !fileMapping) return error
+
+  let stack = error.stack
+
+  // Create reverse mapping (temp.mjs -> original.ts)
+  const reverseMap = new Map()
+  for (const [tsFile, mjsFile] of fileMapping.entries()) {
+    reverseMap.set(mjsFile, tsFile)
+  }
+
+  // Replace all temp.mjs references with original .ts files
+  for (const [mjsFile, tsFile] of reverseMap.entries()) {
+    const mjsPattern = mjsFile.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+    stack = stack.replace(new RegExp(mjsPattern, 'g'), tsFile)
+  }
+
+  error.stack = stack
+  return error
+}
+
+/**
+ * Clean up temporary transpiled files
+ * @param {string[]} tempFiles - Array of temp file paths to delete
+ */
+export function cleanupTempFiles(tempFiles) {
+  for (const file of tempFiles) {
+    if (fs.existsSync(file)) {
+      try {
+        fs.unlinkSync(file)
+      } catch (err) {
+        // Ignore cleanup errors
+      }
+    }
+  }
+}