configorama 0.6.19 → 0.7.0

package/src/resolvers/valueFromFile.js

@@ -7,7 +7,7 @@ const { splitCsv } = require('../utils/strings/splitCsv')
 const { resolveFilePathFromMatch, resolveFilePath } = require('../utils/paths/getFullFilePath')
 const { findNestedVariables } = require('../utils/variables/findNestedVariables')
 const { makeBox } = require('@davidwells/box-logger')
-const { encodeJsSyntax } = require('../utils/encoders/js-fixes')
+const { encodeJsSyntax, decodeJsonInVariable, hasEncodedJson } = require('../utils/encoders/js-fixes')
 
 /* File Parsers */
 const YAML = require('../parsers/yaml')
@@ -15,6 +15,29 @@ const TOML = require('../parsers/toml')
 const INI = require('../parsers/ini')
 const JSON5 = require('../parsers/json5')
 
+/**
+ * Recursively clean encoded JSON from an object
+ * @param {*} obj - Object to clean
+ * @returns {*} Cleaned object
+ */
+function cleanEncodedJson(obj) {
+  if (!obj) return obj
+  if (typeof obj === 'string') {
+    return decodeJsonInVariable(obj)
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(cleanEncodedJson)
+  }
+  if (typeof obj === 'object') {
+    const cleaned = {}
+    for (const key of Object.keys(obj)) {
+      cleaned[key] = cleanEncodedJson(obj[key])
+    }
+    return cleaned
+  }
+  return obj
+}
+
 /**
  * Parse file contents based on file extension
  * @param {string} content - Raw file contents
@@ -86,6 +109,17 @@ async function getValueFromFile(ctx, variableString, options) {
       matchedFileString = argsFound[0]
       argsToPass = argsFound.filter((arg, i) => {
         return i !== 0
+      }).map((arg) => {
+        // Decode base64-encoded JSON objects passed as args
+        if (hasEncodedJson(arg)) {
+          const decoded = decodeJsonInVariable(arg)
+          try {
+            return JSON.parse(decoded)
+          } catch (e) {
+            return decoded
+          }
+        }
+        return arg
       })
     }
   }
@@ -137,9 +171,8 @@ async function getValueFromFile(ctx, variableString, options) {
 
   ctx.fileRefsFound.push(fileRefEntry)
 
-  let fileExtension = resolvedPath.split('.')
-
-  fileExtension = fileExtension[fileExtension.length - 1].toLowerCase()
+  const fileExtParts = resolvedPath.split('.')
+  const fileExtension = fileExtParts[fileExtParts.length - 1].toLowerCase()
 
   // Validate file exists
   if (!exists) {
@@ -168,14 +201,14 @@ async function getValueFromFile(ctx, variableString, options) {
       const errorMsg = makeBox({
         title: `File Not Found in ${originalVar}`,
         minWidth: '100%',
-        text: `Variable ${variableString} cannot resolve due to missing file.
+        content: `Variable ${variableString} cannot resolve due to missing file.
 
 File not found ${fullFilePath}
 
 Default fallback value will be used if provided.
 
 ${JSON.stringify(options.context, null, 2)}`,
-  })
+      })
       console.log(errorMsg)
     }
     // TODO maybe reject. YAML does not allow for null/undefined values
@@ -197,11 +230,17 @@ ${JSON.stringify(options.context, null, 2)}`,
     return Promise.resolve(valueToPopulate)
   }
 
+  // Clean encoded JSON from currentConfig for cleaner context
+  const cleanedCurrentConfig = cleanEncodedJson(ctx.config)
+
   // Build context for executable files
   const valueForFunction = {
+    options: ctx.opts.options || {},
     originalConfig: ctx.originalConfig,
-    config: ctx.config,
-    opts: ctx.opts,
+    currentConfig: cleanedCurrentConfig,
+    argsToPass,
+    // maybe helper fns
+    // maybe the lib instance itself for nested lookups
   }
 
   // Process JS files
@@ -230,8 +269,14 @@ ${JSON.stringify(options.context, null, 2)}`,
     try {
       const tsFile = await executeTypeScriptFile(fullFilePath, { dynamicArgs: () => argsToPass })
       let returnValueFunction = tsFile.config || tsFile.default || tsFile
-      if (moduleName) {
+      // For default export functions with :property syntax, keep the function and use deep properties
+      // For named exports (non-function module), look up the named export
+      let includeFirstProperty = false
+      if (moduleName && typeof returnValueFunction !== 'function') {
         returnValueFunction = tsFile[moduleName]
+      } else if (moduleName && typeof returnValueFunction === 'function') {
+        // Default export function with property access - include first property in path
+        includeFirstProperty = true
       }
 
       return processExecutableFile({
@@ -243,7 +288,8 @@ ${JSON.stringify(options.context, null, 2)}`,
         matchedFileString,
         relativePath,
         fileType: 'TypeScript',
-        getDeeperValue: ctx.getDeeperValue
+        getDeeperValue: ctx.getDeeperValue,
+        includeFirstProperty
       })
     } catch (err) {
       return Promise.reject(new Error(`Error processing TypeScript file: ${err.message}`))
@@ -257,8 +303,14 @@ ${JSON.stringify(options.context, null, 2)}`,
     try {
       const esmFile = await executeESMFile(fullFilePath, { dynamicArgs: () => argsToPass })
       let returnValueFunction = esmFile.config || esmFile.default || esmFile
-      if (moduleName) {
+      // For default export functions with :property syntax, keep the function and use deep properties
+      // For named exports (non-function module), look up the named export
+      let includeFirstProperty = false
+      if (moduleName && typeof returnValueFunction !== 'function') {
         returnValueFunction = esmFile[moduleName]
+      } else if (moduleName && typeof returnValueFunction === 'function') {
+        // Default export function with property access - include first property in path
+        includeFirstProperty = true
       }
 
       return processExecutableFile({
@@ -270,7 +322,8 @@ ${JSON.stringify(options.context, null, 2)}`,
         matchedFileString,
         relativePath,
         fileType: 'ESM',
-        getDeeperValue: ctx.getDeeperValue
+        getDeeperValue: ctx.getDeeperValue,
+        includeFirstProperty
       })
     } catch (err) {
       return Promise.reject(new Error(`Error processing ESM file: ${err.message}`))
@@ -295,15 +348,15 @@ ${JSON.stringify(options.context, null, 2)}`,
       }
       // console.log('deep', variableString)
       // console.log('matchedFileString', matchedFileString)
-      let deepProperties = variableString.replace(matchedFileString, '')
+      const deepPropertiesStr = variableString.replace(matchedFileString, '')
       // Support both : and . as the separator for sub properties
-      const firstChar = deepProperties.substring(0, 1)
+      const firstChar = deepPropertiesStr.substring(0, 1)
       if (firstChar !== ':' && firstChar !== '.') {
         const errorMessage = `Invalid variable syntax when referencing file "${relativePath}" sub properties
-Please use ":" or "." to reference sub properties. ${deepProperties}`
+Please use ":" or "." to reference sub properties. ${deepPropertiesStr}`
         return Promise.reject(new Error(errorMessage))
       }
-      deepProperties = deepProperties.slice(1).split('.')
+      const deepProperties = deepPropertiesStr.slice(1).split('.')
       return ctx.getDeeperValue(deepProperties, valueToPopulate)
     }
 
@@ -360,13 +413,21 @@ function parseModuleReference(variableString, matchedFileString) {
  * Extracts deep properties from variable string after file match
  * @param {string} variableString - The full variable string
  * @param {string} matchedFileString - The matched file path portion
+ * @param {boolean} [includeFirstProperty=false] - Include first property (for default exports)
  * @returns {string[]} Array of property keys to traverse
  */
-function extractDeepProperties(variableString, matchedFileString) {
-  let deepProperties = variableString.replace(matchedFileString, '')
-  deepProperties = deepProperties.slice(1).split('.')
-  deepProperties.splice(0, 1)
-  return deepProperties.map((prop) => trim(prop))
+function extractDeepProperties(variableString, matchedFileString, includeFirstProperty = false) {
+  const deepPropertiesStr = variableString.replace(matchedFileString, '')
+  if (!deepPropertiesStr || deepPropertiesStr === '') {
+    return []
+  }
+  const deepProperties = deepPropertiesStr.slice(1).split('.')
+  // For named exports, skip first property (it's the module name)
+  // For default exports, keep all properties
+  if (!includeFirstProperty) {
+    deepProperties.splice(0, 1)
+  }
+  return deepProperties.map((prop) => trim(prop)).filter(Boolean)
 }
 
 /**
@@ -381,6 +442,7 @@ function extractDeepProperties(variableString, matchedFileString) {
  * @param {string} params.relativePath - Relative file path for errors
  * @param {string} params.fileType - Type of file (javascript/TypeScript/ESM)
  * @param {Function} params.getDeeperValue - Function to resolve nested values
+ * @param {boolean} [params.includeFirstProperty=false] - Include first property in path (for default exports)
  * @returns {Promise<any>}
  */
 async function processExecutableFile({
@@ -392,7 +454,8 @@ async function processExecutableFile({
   matchedFileString,
   relativePath,
   fileType,
-  getDeeperValue
+  getDeeperValue,
+  includeFirstProperty = false
 }) {
   if (typeof returnValueFunction !== 'function') {
     const errorMessage = `Invalid variable syntax when referencing file "${relativePath}".
@@ -400,10 +463,10 @@ Check if your ${fileType} is exporting a function that returns a value.`
     return Promise.reject(new Error(errorMessage))
   }
 
-  const valueToPopulate = returnValueFunction.call(fileModule, valueForFunction, ...argsToPass)
+  const valueToPopulate = returnValueFunction.call(fileModule, ...argsToPass, valueForFunction)
 
   return Promise.resolve(valueToPopulate).then((valueToPopulateResolved) => {
-    const deepProperties = extractDeepProperties(variableString, matchedFileString)
+    const deepProperties = extractDeepProperties(variableString, matchedFileString, includeFirstProperty)
     return getDeeperValue(deepProperties, valueToPopulateResolved).then((deepValueToPopulateResolved) => {
       if (typeof deepValueToPopulateResolved === 'undefined') {
         const errorMessage = `Invalid variable syntax when referencing file "${relativePath}".

package/src/resolvers/valueFromGit.js

@@ -10,13 +10,19 @@ const { findProjectRoot } = require('../utils/paths/findProjectRoot')
 const GIT_PREFIX = 'git'
 const gitVariableSyntax = RegExp(/^git:/g)
 
+/**
+ * Execute a shell command
+ * @param {string} cmd - Command to execute
+ * @param {import('child_process').ExecOptions} [options] - Exec options
+ * @returns {Promise<string>}
+ */
 async function _exec(cmd, options = { timeout: 1000 }) {
   return new Promise((resolve, reject) => {
     childProcess.exec(cmd, options, (err, stdout) => {
       if (err) {
         return reject(err)
       }
-      return resolve(stdout.trim())
+      return resolve(String(stdout).trim())
     })
   })
 }
@@ -213,8 +219,10 @@ const cache = new Map()
 
 /**
  * Gets the last Git commit timestamp for a file
- * @param {string} file - Path to the file to check
- * @returns {Promise<Date|undefined>} The commit timestamp or undefined if not in Git
+ * @param {string} _file - Path to the file to check
+ * @param {string} cwd - Working directory
+ * @param {boolean} [throwOnMissing] - Whether to throw on missing file
+ * @returns {Promise<string|undefined>} The commit timestamp ISO string or undefined if not in Git
  */
 async function getGitTimestamp(_file, cwd, throwOnMissing = true) {
   // Validate file path to prevent command injection

package/src/utils/encoders/js-fixes.js

@@ -1,6 +1,9 @@
 const PAREN_OPEN_PLACEHOLDER = '__PH_PAREN_OPEN__'
 const OPEN_PAREN_PLACEHOLDER_PATTERN = /__PH_PAREN_OPEN__/g
 
+const JSON_ENCODED_PREFIX = '__JSON_B64__'
+const JSON_ENCODED_PATTERN = /__JSON_B64__([A-Za-z0-9+/=]+)__/g
+
 function encodeJsSyntax(value = '') {
   return value.replace(/\(/g, PAREN_OPEN_PLACEHOLDER)
 }
@@ -14,9 +17,50 @@ function hasParenthesesPlaceholder(value = '') {
   return OPEN_PAREN_PLACEHOLDER_PATTERN.test(value)
 }
 
+/**
+ * Encode a JSON object to base64 for safe embedding in variable strings
+ * @param {object} obj - Object to encode
+ * @returns {string} Encoded string like __JSON_B64__eyJmb28iOiJiYXIifQ==__
+ */
+function encodeJsonForVariable(obj) {
+  const jsonStr = JSON.stringify(obj)
+  const b64 = Buffer.from(jsonStr).toString('base64')
+  return `${JSON_ENCODED_PREFIX}${b64}__`
+}
+
+/**
+ * Decode base64-encoded JSON from variable strings
+ * @param {string} value - String potentially containing encoded JSON
+ * @returns {string} String with encoded JSON decoded back to JSON strings
+ */
+function decodeJsonInVariable(value) {
+  if (!value || typeof value !== 'string') return value
+  return value.replace(JSON_ENCODED_PATTERN, (match, b64) => {
+    try {
+      const jsonStr = Buffer.from(b64, 'base64').toString('utf8')
+      return jsonStr
+    } catch (e) {
+      return match
+    }
+  })
+}
+
+/**
+ * Check if string contains encoded JSON
+ * @param {string} value - String to check
+ * @returns {boolean}
+ */
+function hasEncodedJson(value) {
+  if (!value || typeof value !== 'string') return false
+  return value.includes(JSON_ENCODED_PREFIX)
+}
+
 module.exports = {
   OPEN_PAREN_PLACEHOLDER_PATTERN,
   hasParenthesesPlaceholder,
   encodeJsSyntax,
   decodeJsSyntax,
+  encodeJsonForVariable,
+  decodeJsonInVariable,
+  hasEncodedJson,
 }

package/src/utils/parsing/mergeByKeys.js

@@ -3,9 +3,10 @@
  */
 function mergeByKeys(data, path, keysToMerge) {
   if (!data) return {}
-  
-  const items = path.split('.').reduce((obj, key) => obj?.[key], data)
-  if (!Array.isArray(items)) return {}
+
+  // Handle empty path - operate on root data
+  const items = path ? path.split('.').reduce((obj, key) => obj?.[key], data) : data
+  if (!Array.isArray(items)) return data
   
   const result = {}
   const mergeAll = !keysToMerge || !Array.isArray(keysToMerge) || keysToMerge.length === 0

package/src/utils/parsing/parse.js

@@ -31,12 +31,12 @@ function parseFileContents({ contents, filePath, varRegex, dynamicArgs }) {
 
   if (fileType.match(/\.(yml|yaml)/i)) {
     try {
-      const ymlText = YAML.preProcess(contents, regex)
+      const ymlText = YAML.preProcess(contents)
       configObject = YAML.parse(ymlText)
     } catch (err) {
       // Attempt to fix cloudformation refs
       if (err.message.match(/YAMLException/)) {
-        const ymlText = YAML.preProcess(contents, regex)
+        const ymlText = YAML.preProcess(contents)
         const result = YAML.load(ymlText, {
           filename: filePath,
           schema: cloudFormationSchema.schema,
@@ -82,6 +82,8 @@ function parseFileContents({ contents, filePath, varRegex, dynamicArgs }) {
         configObject = (typeof configObject.config === 'function') ? configObject.config(jsArgs) : configObject.config
       } else if (configObject.default) {
         configObject = (typeof configObject.default === 'function') ? configObject.default(jsArgs) : configObject.default
+      } else if (typeof configObject === 'function') {
+        configObject = configObject(jsArgs)
       }
       // console.log('parseFileContents configObject', configObject)
     } catch (err) {

package/src/utils/paths/getFullFilePath.js

@@ -40,7 +40,7 @@ function getFullPath(fileString, cwd) {
  * @param {string} matchedFileString - The matched file string (e.g., "file(path/to/file.js)")
  * @param {RegExp} syntax - The regex pattern used to match the file string (e.g., fileRefSyntax or textRefSyntax)
  * @param {string} configPath - The base directory path for resolving relative paths
- * @returns {{fullFilePath: string|null, resolvedPath: string}} - Object containing the resolved full file path and the resolved path (after alias resolution)
+ * @returns {{fullFilePath: string, resolvedPath: string, relativePath: string}} - Object containing the resolved full file path, resolved path (after alias resolution), and relative path
  */
 function resolveFilePathFromMatch(matchedFileString, syntax, configPath) {
   const relativePath = trimSurroundingQuotes(

package/src/utils/resolution/preResolveVariable.js

@@ -36,6 +36,7 @@ function hasUnresolvedVars(str, variableSyntax) {
  * @param {object} context.config - Original config object
  * @param {string} context.configDir - Config file directory
  * @param {RegExp} context.variableSyntax - Variable syntax regex
+ * @param {object} [context.options] - CLI options
  * @returns {Promise<*>} Resolved value or undefined if can't pre-resolve
  */
 async function preResolveSingle(varString, context) {

package/src/utils/strings/quoteUtils.js

@@ -43,8 +43,8 @@ function endChar(str, char) {
 /**
  * Ensures a value (string or array of strings) has quotes around it
  * @param {string|string[]} value - The value to quote
- * @param {string} open - Opening quote character (default: '"')
- * @param {string} close - Closing quote character (default: same as open)
+ * @param {string} [open] - Opening quote character (default: '"')
+ * @param {string} [close] - Closing quote character (default: same as open)
  * @returns {string|string[]} The quoted value(s)
  */
 function ensureQuote(value, open = '"', close) {

package/src/utils/strings/splitCsv.js

@@ -5,7 +5,7 @@ const { splitByComma } = require('./splitByComma')
  * NOTE: This is a simpler version that delegates to splitByComma for consistency.
  * For advanced use cases with bracket depth tracking and regex protection, use splitByComma directly.
  * @param {string} str - String to split
- * @param {string} splitter - Optional custom splitter (defaults to ',')
+ * @param {string} [splitter] - Optional custom splitter (defaults to ',')
  * @returns {string[]} Array of split strings
  */
 function splitCsv(str, splitter) {

package/src/utils/ui/logs.js

@@ -2,10 +2,10 @@ const { makeHeader, logHeader : logHeaderBox } = require('@davidwells/box-logger
 
 function logHeader(message) {
   logHeaderBox({
-    content: message, 
-    rightBorder: true, 
-    minWidth: 80, 
-    textStyle: 'bold',
+    content: message,
+    borderRight: true,
+    minWidth: 80,
+    fontStyle: 'bold',
     borderStyle: 'bold',
     borderColor: 'cyanBright',
   })

package/src/utils/validation/warnIfNotFound.js

@@ -14,9 +14,9 @@ function isValidValue(val) {
  * Check if variable resolved to valid value, log warning if not
  * @param {string} variableString - The variable being resolved
  * @param {*} valueToPopulate - The resolved value
- * @param {object} options - Configuration options
- * @param {object} options.patterns - Regex patterns for variable types
- * @param {boolean} options.debug - Whether to log warnings
+ * @param {object} [options] - Configuration options
+ * @param {object} [options.patterns] - Regex patterns for variable types
+ * @param {boolean} [options.debug] - Whether to log warnings
  * @returns {*} The valueToPopulate unchanged
  */
 function warnIfNotFound(variableString, valueToPopulate, options = {}) {

package/src/utils/variables/findNestedVariables.js

@@ -338,10 +338,10 @@ function findNestedVariablesOld(input, regex, variablesKnownTypes, debug = false
 
   // Replace the `__REPLACED_${iteration - 1}__` with the original match
   matches = matches.map((match, index) => {
-    const indexOfReplaced = match.varMatch.match(/__REPLACED_(\d+)__/)
+    const indexOfReplaced = match.fullMatch.match(/__REPLACED_(\d+)__/)
     if (indexOfReplaced) {
       const replacedIndex = parseInt(indexOfReplaced[1])
-      match.varMatch = match.varMatch.replace(`__REPLACED_${replacedIndex}__`, matches[replacedIndex].variable)
+      match.fullMatch = match.fullMatch.replace(`__REPLACED_${replacedIndex}__`, matches[replacedIndex].variable)
       match.variable = match.variable.replace(`__REPLACED_${replacedIndex}__`, matches[replacedIndex].variable)
     }
     return match

package/types/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map

package/types/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../cli.js"],"names":[],"mappings":""}

package/types/src/functions/md5.d.ts

@@ -0,0 +1,3 @@
+declare function _exports(string: string): string;
+export = _exports;
+//# sourceMappingURL=md5.d.ts.map

package/types/src/functions/md5.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"md5.d.ts","sourceRoot":"","sources":["../../../src/functions/md5.js"],"names":[],"mappings":"AAOiB,kCAHL,MAAM,GACN,MAAM,CAOjB"}

package/types/src/index.d.ts

@@ -0,0 +1,100 @@
+declare namespace _exports {
+    export { ConfigoramaSettings, ConfigoramaResult };
+}
+declare function _exports<T = any>(configPathOrObject: string | any, settings?: ConfigoramaSettings): Promise<T | ConfigoramaResult<T>>;
+declare namespace _exports {
+    export { Configorama };
+    export function sync<T = any>(configPathOrObject: string | any, settings?: ConfigoramaSettings): T;
+    export function analyze(configPathOrObject: string | object, settings?: object): Promise<any>;
+    export { parsers as format };
+}
+export = _exports;
+type ConfigoramaSettings = {
+    /**
+     * - options to populate for ${opt:xyz}. These could be CLI flags
+     */
+    options?: {
+        [x: string]: any;
+    };
+    /**
+     * - Regex of variable syntax
+     */
+    syntax?: string;
+    /**
+     * - cwd of config. Needed if raw object passed in instead of file path
+     */
+    configDir?: string;
+    /**
+     * - array of custom variable sources
+     */
+    variableSources?: any[];
+    /**
+     * - Object of custom filters
+     */
+    filters?: {
+        [x: string]: Function;
+    };
+    /**
+     * - Object of custom functions
+     */
+    functions?: {
+        [x: string]: Function;
+    };
+    /**
+     * - allow unknown variables to pass through without throwing errors
+     */
+    allowUnknownVars?: boolean;
+    /**
+     * - allow undefined values to pass through without throwing errors
+     */
+    allowUndefinedValues?: boolean;
+    /**
+     * - values passed into .js config files if user using javascript config
+     */
+    dynamicArgs?: any | Function;
+    /**
+     * - return both config and metadata about variables found
+     */
+    returnMetadata?: boolean;
+    /**
+     * - keys to merge in arrays of objects
+     */
+    mergeKeys?: string[];
+    /**
+     * - map of file paths to override
+     */
+    filePathOverrides?: {
+        [x: string]: string;
+    };
+};
+type ConfigoramaResult<T = any> = {
+    /**
+     * - The variable syntax pattern used
+     */
+    variableSyntax: RegExp;
+    /**
+     * - Map of variable types found
+     */
+    variableTypes: {
+        [x: string]: any;
+    };
+    /**
+     * - The resolved configuration object
+     */
+    config: T;
+    /**
+     * - The original unresolved configuration
+     */
+    originalConfig: any;
+    /**
+     * - Metadata about variables found and resolved
+     */
+    metadata: any;
+    /**
+     * - Resolution history per path for debugging
+     */
+    resolutionHistory: any;
+};
+import Configorama = require("./main");
+import parsers = require("./parsers");
+//# sourceMappingURL=index.d.ts.map

package/types/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":";;;AAwCiB,0BALH,CAAC,4BACJ,MAAM,MAAO,aACb,mBAAmB,GACjB,OAAO,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAiD7C;;;IASqB,qBALR,CAAC,4BACJ,MAAM,MAAO,aACb,mBAAmB,GACjB,CAAC,CAgBb;IAQwB,4CAJb,MAAM,GAAC,MAAM,aACd,MAAM,gBAUhB;;;;;;;;;;;;;;aApHa,MAAM;;;;gBACN,MAAM;;;;;;;;;;;;;;;;;;;;uBAIN,OAAO;;;;2BACP,OAAO;;;;kBACP,cAAe;;;;qBACf,OAAO;;;;gBACP,MAAM,EAAE;;;;;;;;uBAKR,CAAC;;;;oBAED,MAAM;;;;;;;;;;YAEN,CAAC"}