configorama 0.9.17 → 0.10.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "configorama",
-  "version": "0.9.17",
+  "version": "0.10.2",
   "description": "Variable support for configuration files",
   "main": "src/index.js",
   "types": "index.d.ts",
@@ -71,16 +71,19 @@
   "devDependencies": {
     "@cdktf/hcl2json": "^0.21.0",
     "@types/node": "^24.10.1",
-    "markdown-magic": "^3.4.0",
+    "markdown-magic": "^4.8.0",
     "tsx": "^4.7.0",
     "typescript": "^5.8.3",
     "uvu": "^0.5.6",
     "watchlist": "^0.3.1"
   },
+  "overrides": {
+    "lodash": "^4.18.1"
+  },
   "peerDependencies": {
     "@cdktf/hcl2json": ">=0.20.0",
-    "tsx": ">=4.0.0",
-    "ts-node": ">=10.0.0"
+    "ts-node": ">=10.0.0",
+    "tsx": ">=4.0.0"
   },
   "peerDependenciesMeta": {
     "@cdktf/hcl2json": {

package/src/main.js

@@ -8,7 +8,37 @@ console.log = () => {}
 /** */
 /* External dependencies */
 const findUp = require('find-up')
-const traverse = require('traverse')
+/**
+ * Pre-order DFS walk that mimics the subset of `traverse(obj).forEach(fn)`
+ * we actually use: only `this.path` and `this.update(v)`. ~2x faster than
+ * the `traverse` package because it avoids the per-node State object alloc.
+ *
+ * @param {*} root
+ * @param {Function} callback - called with `this = {path, update}` per node
+ */
+function walkAndUpdate(root, callback) {
+  function visit(value, path, parent, key) {
+    const ctx = {
+      path,
+      update(newValue) { if (parent !== null) parent[key] = newValue }
+    }
+    callback.call(ctx, value)
+    // Re-read in case callback mutated the slot
+    const current = parent === null ? root : parent[key]
+    if (current !== null && typeof current === 'object') {
+      // Use Object.keys for both arrays and objects so sparse-array holes are
+      // skipped, matching the `traverse` package's behavior.
+      const keys = Object.keys(current)
+      const isArr = Array.isArray(current)
+      for (let i = 0; i < keys.length; i++) {
+        const k = keys[i]
+        const idx = isArr ? Number(k) : k
+        visit(current[k], path.concat(idx), current, k)
+      }
+    }
+  }
+  visit(root, [], null, null)
+}
 const dotProp = require('dot-prop')
 /* Utils - root */
 const {
@@ -158,6 +188,22 @@ class Configorama {
     this.filterCache = {}
     // Cache for originalValue lookups (perf: avoid repeated dotProp.get)
     this._originalValueCache = new Map()
+    // Paths whose current value is a literal with no variables — skip rebuilding
+    // their leaf object on every subsequent populateObjectImpl iteration.
+    this._resolvedPaths = new Set()
+    // Cache raw file contents per absolute path so repeated ${file:...} refs
+    // to the same file (e.g., merged twice into different keys) don't reread.
+    this._fileContentCache = new Map()
+
+    // rawOriginalConfig (a pre-preProcess snapshot) is only consumed by metadata
+    // display paths. Skipping the cloneDeep when none of those paths are active
+    // saves ~10-15ms per init.
+    const showFound = this.settings.dynamicArgs && (this.settings.dynamicArgs.list || this.settings.dynamicArgs.info)
+    this._needsRawClone = !!(
+      this.settings.returnMetadata ||
+      this.settings.returnPreResolvedVariableDetails ||
+      VERBOSE || SETUP_MODE || showFound
+    )
 
     this.foundVariables = []
     this.fileRefsFound = []
@@ -188,6 +234,10 @@ class Configorama {
     }
     const variableSyntax = varRegex
     this.variableSyntax = variableSyntax
+    // Non-global twin for cheap boolean checks: `.test()` on a global regex
+    // would advance lastIndex between calls, and `.match()` on a global regex
+    // allocates an array of every match. Use this whenever we only need truthy.
+    this.variableSyntaxTest = new RegExp(variableSyntax.source, variableSyntax.flags.replace('g', ''))
 
     // Extract variable prefix/suffix from syntax regex for reconstructing variables
     const syntaxWrapper = extractVariableWrapper(variableSyntax.source)
@@ -200,8 +250,10 @@ class Configorama {
 
     // Set initial config object to populate
     if (typeof fileOrObject === 'object') {
-      // Store truly raw config before any preprocessing
-      this.rawOriginalConfig = cloneDeep(fileOrObject)
+      // Store truly raw config before any preprocessing (only when needed)
+      if (this._needsRawClone) {
+        this.rawOriginalConfig = cloneDeep(fileOrObject)
+      }
       // Preprocess: convert bare refs in if(), escape help() args
       // Skip fallback fixing for object configs (they handle bare refs differently)
       const processed = preProcess(fileOrObject, this.variableSyntax, this.variableTypes, { skipFallbackFix: true })
@@ -677,8 +729,10 @@ class Configorama {
       /*
       console.log('before preprocess', configObject)
       /** */
-      // Store truly raw config before any preprocessing (for metadata display)
-      this.rawOriginalConfig = cloneDeep(configObject)
+      // Store truly raw config before any preprocessing (only when needed)
+      if (this._needsRawClone) {
+        this.rawOriginalConfig = cloneDeep(configObject)
+      }
 
       /* Preprocess step here - escapes ${} in help() args, fixes malformed fallbacks */
       configObject = preProcess(configObject, this.variableSyntax, this.variableTypes)
@@ -816,7 +870,7 @@ class Configorama {
     const originalConfig = this.originalConfig
 
     /* If no variables found just return early */
-    if (this.originalString && !this.originalString.match(this.variableSyntax)) {
+    if (this.originalString && !this.variableSyntaxTest.test(this.originalString)) {
       if (this._markdownContent !== undefined) {
         this.originalConfig[this._markdownContentKey] = this._markdownContent
       }
@@ -829,7 +883,7 @@ class Configorama {
       /* has hardcoded stage */
       if (
         this.originalConfig && this.originalConfig.provider && 
-        this.originalConfig.provider.stage && !this.originalConfig.provider.stage.match(this.variableSyntax)
+        this.originalConfig.provider.stage && !this.variableSyntaxTest.test(this.originalConfig.provider.stage)
       ) {
         providerStage = this.originalConfig.provider.stage
       }
@@ -859,7 +913,7 @@ class Configorama {
             // console.log('leaves two', leaves)
             // Traverse resolved object and run functions
             // console.log('this.config', this.config)
-            traverse(this.config).forEach(function (rawValue) {
+            walkAndUpdate(this.config, function (rawValue) {
               /* Pass through unknown variables */
               if (!configoramaOpts.allowUndefinedValues && typeof rawValue === 'undefined') {
                 const configValuePath = this.path.join('.')
@@ -1048,6 +1102,11 @@ class Configorama {
   // #######################
   // ## PROPERTY HANDLING ##
   // #######################
+  isCloudFormationSubPath(pathValue) {
+    if (!pathValue || !pathValue.length) return false
+    return pathValue[pathValue.length - 1] === 'Fn::Sub'
+  }
+
   /**
    * The declaration of a terminal property.  This declaration includes the path and value of the
    * property.
@@ -1096,12 +1155,16 @@ class Configorama {
         mapValues(current, addContext)
       }
     } else {
+      // Compute path once, then skip work for paths already known to be fully resolved.
+      const thePath = context.length > 1 ? context.join('.') : context[0]
+      if (this._resolvedPaths.has(thePath)) {
+        return results
+      }
       // TODO Add values to leaves here
       const leaf = {
         path: context,
         value: current,
       }
-      const thePath = leaf.path.length > 1 ? leaf.path.join('.') : leaf.path[0]
       // console.log('thePath', thePath)
       // console.log('this.originalConfig', this.originalConfig)
 
@@ -1113,21 +1176,39 @@ class Configorama {
         originalValue = cached.value
         originalValuePath = cached.originalValuePath
       } else {
-        originalValue = dotProp.get(this.originalConfig, thePath)
-        // TODO @DWELLS make recursive
+        // Walk down originalConfig once using the path array directly. Avoids
+        // dotProp.get's path-segmenting work and the previous O(depth²) loop
+        // that re-joined and re-walked parent paths.
+        const ancestorValues = []
+        let node = this.originalConfig
+        let fullPathReached = true
+        for (let i = 0; i < context.length; i++) {
+          if (node == null || typeof node !== 'object') {
+            fullPathReached = false
+            break
+          }
+          node = node[context[i]]
+          ancestorValues.push(node)
+        }
+
+        const lastIdx = ancestorValues.length - 1
+        originalValue = fullPathReached ? ancestorValues[lastIdx] : undefined
+
         if (!originalValue) {
-          // Recurse up the tree until we find a value
-          // Use index instead of slice() to avoid array allocations
-          for (let pathLen = leaf.path.length - 1; pathLen > 0 && !originalValue; pathLen--) {
-            const currentPath = leaf.path.slice(0, pathLen).join('.')
-            // console.log('checking parent path:', currentPath)
-            originalValue = dotProp.get(this.originalConfig, currentPath)
-            if (typeof originalValue !== 'undefined') {
-              originalValuePath = currentPath
+          // Same semantics as the previous "recurse up" loop: walk from the
+          // deepest non-full ancestor toward the root, take the first truthy
+          // ancestor as originalValue, and update originalValuePath each time
+          // we see a defined ancestor along the way.
+          const startIdx = fullPathReached ? lastIdx - 1 : lastIdx
+          for (let i = startIdx; i >= 0; i--) {
+            const ancestor = ancestorValues[i]
+            if (typeof ancestor !== 'undefined') {
+              originalValuePath = i > 0 ? context.slice(0, i + 1).join('.') : context[0]
+              originalValue = ancestor
+              if (ancestor) break
             }
           }
         }
-        // Cache the result
         this._originalValueCache.set(thePath, { value: originalValue, originalValuePath })
       }
       if (originalValuePath) {
@@ -1150,6 +1231,9 @@ class Configorama {
           leaf.isFileRef = true
         }
       }
+      // Pre-compute hasVar so populateVariables doesn't have to re-test every leaf
+      // every iteration. Non-string values can never contain a variable.
+      leaf.hasVar = isString(current) && this.variableSyntaxTest.test(current)
       // dotProp.get(this.originalConfig, thePath)
       results.push(leaf)
     }
@@ -1167,9 +1251,23 @@ class Configorama {
    */
   populateVariables(properties) {
     // console.log('properties', properties)
+    // hasVar was precomputed in getProperties — no need to re-test the regex here.
+    // Properties whose value is defined and lacks a variable are terminally
+    // resolved: record their path so getProperties can skip them on the next
+    // iteration. Undefined-valued leaves stay eligible — the final
+    // undefined-detection traverse still needs to find them in this.leaves.
     let variables = properties.filter((property) => {
-      // Initial check if value has variable string in it
-      return isString(property.value) && property.value.match(this.variableSyntax)
+      if (property.hasVar) return true
+      if (property.value !== undefined) {
+        const p = property.path
+        this._resolvedPaths.add(p.length > 1 ? p.join('.') : p[0])
+      }
+      return false
+    })
+    /* Leave CloudFormation Fn::Sub bodies verbatim. ${...} inside a !Sub is a
+       CloudFormation reference, not a configorama variable. */
+    variables = variables.filter((property) => {
+      return !this.isCloudFormationSubPath(property.path)
     })
     /*
     console.log(`variables at call count ${this.callCount}`, variables)
@@ -1205,6 +1303,15 @@ class Configorama {
         if (result.value !== result.populated) {
           set(target, result.path, result.populated)
         }
+        // If the populated value is defined and no longer contains a variable,
+        // mark this path resolved so getProperties skips it on subsequent
+        // iterations. Undefined means resolution failed — keep it eligible so
+        // the final undefined-detection traverse still has a leaf to reference.
+        const populated = result.populated
+        if (populated !== undefined && (typeof populated !== 'string' || !this.variableSyntaxTest.test(populated))) {
+          const p = result.path
+          this._resolvedPaths.add(p.length > 1 ? p.join('.') : p[0])
+        }
       })
     })
   }
@@ -1354,7 +1461,7 @@ class Configorama {
         historyEntry.fallbackValues = variableParts.slice(1).map((fallback) => {
           const trimmedFallback = fallback.trim()
           // Check if it's a variable reference
-          const isVariable = trimmedFallback.match(this.variableSyntax) || trimmedFallback.match(this.variablesKnownTypes)
+          const isVariable = this.variableSyntaxTest.test(trimmedFallback) || this.variablesKnownTypes.test(trimmedFallback)
           const fallbackData = {
             isVariable: !!isVariable,
             fullMatch: trimmedFallback,
@@ -1448,6 +1555,9 @@ class Configorama {
       console.log(valueObject)
     }
     const property = valueObject.value
+    if (this.isCloudFormationSubPath(valueObject.path)) {
+      return Promise.resolve(property)
+    }
     const matches = this.getMatches(property)
     /*
     console.log('populateValue matches', matches)
@@ -1592,7 +1702,7 @@ class Configorama {
       }
 
       /* Handle ${self:custom.ref, ''} with deep values */
-      if (v.match(deepRefSyntax) && originalSrc.match(this.variableSyntax) && !v.match(/deep\:(\d*)\..*}$/)) {
+      if (v.match(deepRefSyntax) && this.variableSyntaxTest.test(originalSrc) && !v.match(/deep\:(\d*)\..*}$/)) {
         // console.log('deep ref syntax')
         // console.log('deep var', this.deep)
         // console.log('originalSrc', originalSrc)
@@ -1642,8 +1752,8 @@ class Configorama {
       /** */
       // Handle comma ${opt:stage, dev} and remove extra suffix
       if (
-        currentMatchedString.match(this.variableSyntax) &&
-        !valueToPopulate.match(this.variableSyntax) &&
+        this.variableSyntaxTest.test(currentMatchedString) &&
+        !this.variableSyntaxTest.test(valueToPopulate) &&
         valueToPopulate.match(this.varSuffixPattern)
       ) {
         valueToPopulate = valueToPopulate.replace(this.varSuffixPattern, '')
@@ -1651,7 +1761,7 @@ class Configorama {
 
       // For eval/if expressions, string values need quotes unless already quoted
       // BUT don't quote strings that contain variable refs (they need further resolution)
-      if (evalIfPattern.test(property) && !valueToPopulate.match(this.variableSyntax)) {
+      if (evalIfPattern.test(property) && !this.variableSyntaxTest.test(valueToPopulate)) {
         const matchIdx = property.indexOf(currentMatchedString)
         const charBefore = matchIdx > 0 ? property[matchIdx - 1] : ''
         // Always escape quotes in values for eval/if context
@@ -1689,8 +1799,8 @@ class Configorama {
         const isNestedInVariable = (
           property.trim() !== matchedString.trim() &&
           property.indexOf(matchedString) !== -1 &&
-          matchedString.match(this.variableSyntax) &&
-          property.match(this.variableSyntax)
+          this.variableSyntaxTest.test(matchedString) &&
+          this.variableSyntaxTest.test(property)
         )
         // Only encode for file() or text() references where JSON braces break regex matching
         const isFileOrTextRef = /\bfile\s*\(|\btext\s*\(/.test(property)
@@ -1861,7 +1971,7 @@ Missing Value ${missingValue} - ${matchedString}
 
       if (
         /* Not another variable reference */
-        !prop.match(this.variableSyntax)
+        !this.variableSyntaxTest.test(prop)
         &&
         /* Not file or text refs */
         !prop.match(fileRefSyntax)
@@ -1898,7 +2008,7 @@ Missing Value ${missingValue} - ${matchedString}
       typeof valueToPopulate === 'string' &&
       !valueToPopulate.match(deepRefSyntax) &&
       foundFilters.length &&
-      !property.match(this.variableSyntax)
+      !this.variableSyntaxTest.test(property)
     ) {
       runFilters = true
     }
@@ -1977,7 +2087,7 @@ Missing Value ${missingValue} - ${matchedString}
       const secondValue = variableStrings[1]
       if (
         isString(firstValue) && firstValue.match(this.variablesKnownTypes) 
-        && isString(secondValue) && !secondValue.match(this.variablesKnownTypes) && !secondValue.match(this.variableSyntax)
+        && isString(secondValue) && !secondValue.match(this.variablesKnownTypes) && !this.variableSyntaxTest.test(secondValue)
       ) {
         if (!isSurroundedByQuotes(secondValue) && !/^-?\d+(\.\d+)?$/.test(secondValue) && !startsWithQuotedPipe(secondValue)) {
           variableStrings = [firstValue, ensureQuote(secondValue)]
@@ -2009,7 +2119,7 @@ Missing Value ${missingValue} - ${matchedString}
 
       extractedValues.forEach((value, index) => {
         // console.log('───────────────────────────────> value', value)
-        if (isString(value) && value.match(this.variableSyntax)) {
+        if (isString(value) && this.variableSyntaxTest.test(value)) {
           deepProperties += 1
           // console.log('makeDeepVariable overwrite', value)
           const deepVariable = this.makeDeepVariable(value, 'via overwrite')
@@ -2630,7 +2740,8 @@ Missing Value ${missingValue} - ${matchedString}
       fileRefSyntax: fileRefSyntax,
       textRefSyntax: textRefSyntax,
       varPrefix: this.varPrefix,
-      varSuffix: this.varSuffix
+      varSuffix: this.varSuffix,
+      fileContentCache: this._fileContentCache
     }
     return getValueFromFileResolver(ctx, variableString, options)
   }
@@ -2654,7 +2765,7 @@ Missing Value ${missingValue} - ${matchedString}
       // if there is a deep reference remaining
       ret = ret.then((result) => {
         // console.log('DEEP RESULT', result)
-        if (isString(result.value) && result.value.match(this.variableSyntax)) {
+        if (isString(result.value) && this.variableSyntaxTest.test(result.value)) {
           // console.log('makeDeepVariable getValueFromDeep', result.value)
           const deepVariable = this.makeDeepVariable(result.value, 'via getValueFromDeep')
           return Promise.resolve(appendDeepVariable(deepVariable, deepRef))
@@ -2759,7 +2870,7 @@ Missing Value ${missingValue} - ${matchedString}
 
           reducedValue = reducedValue[subProperty]
         }
-        if (typeof reducedValue === 'string' && reducedValue.match(this.variableSyntax)) {
+        if (typeof reducedValue === 'string' && this.variableSyntaxTest.test(reducedValue)) {
           // console.log('makeDeepVariable reducedValue', reducedValue)
           reducedValue = this.makeDeepVariable(reducedValue, 'via getDeeperValue')
         }

package/src/resolvers/valueFromFile.js

@@ -108,6 +108,7 @@ function parseFileContents(content, filePath) {
  * @param {RegExp} ctx.textRefSyntax - Regex for text() syntax
  * @param {string} ctx.varPrefix - Variable prefix (e.g., '${')
  * @param {string} ctx.varSuffix - Variable suffix (e.g., '}')
+ * @param {Map<string, string>} [ctx.fileContentCache] - Optional per-instance read cache keyed by absolute file path
  * @param {string} variableString - The variable string to resolve
  * @param {object} options - Resolution options
  * @returns {Promise<any>}
@@ -254,7 +255,14 @@ ${JSON.stringify(options.context, null, 2)}`,
 
   let valueToPopulate
 
-  const variableFileContents = fs.readFileSync(fullFilePath, 'utf-8')
+  // Per-instance read cache: identical ${file:...} refs hit fs once per resolve.
+  let variableFileContents
+  if (ctx.fileContentCache && ctx.fileContentCache.has(fullFilePath)) {
+    variableFileContents = ctx.fileContentCache.get(fullFilePath)
+  } else {
+    variableFileContents = fs.readFileSync(fullFilePath, 'utf-8')
+    if (ctx.fileContentCache) ctx.fileContentCache.set(fullFilePath, variableFileContents)
+  }
 
   /* handle case for referencing raw JS files to inline them */
   if ((argsToPass.length

package/src/utils/parsing/preProcess.js

@@ -233,12 +233,8 @@ function preProcess(configObject, variableSyntax, variableTypes, options = {}) {
                 const afterOp = afterRef.substring(op.length).trimStart()
                 return afterOp.startsWith('"') || afterOp.startsWith("'")
               }
-              // Check if preceded by: "string" op
-              for (const o of comparisonOps) {
-                const pattern = new RegExp(`["'][^"']*["']\\s*${o.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*$`)
-                if (pattern.test(beforeRef)) return true
-              }
-              return false
+              // Check if preceded by: "string" op (reuses precededByPatterns)
+              return precededByPatterns.some(p => p.test(beforeRef))
             })
 
             if (!precededByQuote && !followedByQuote && isComparedToString) {

package/types/src/index.d.ts

@@ -57,14 +57,6 @@ type ConfigoramaSettings = {
      * - return both config and metadata about variables found
      */
     returnMetadata?: boolean;
-    /**
-     * - suppress env-stage-loader logs when useDotenv/useDotEnv is enabled
-     */
-    dotEnvSilent?: boolean;
-    /**
-     * - enable env-stage-loader debug logs when useDotenv/useDotEnv is enabled
-     */
-    dotEnvDebug?: boolean;
     /**
      * - keys to merge in arrays of objects
      */

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":";;;AAyCiB,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;;;;;;;;;;;;;;;;aAtHa,MAAM;;;;gBACN,MAAM;;;;;;;;;;;;;;;;;;;;uBAIN,OAAO;;;;2BACP,OAAO;;;;kBACP,cAAe;;;;qBACf,OAAO;;;;mBACP,OAAO;;;;kBACP,OAAO;;;;gBACP,MAAM,EAAE;;;;;;;;uBAKR,CAAC;;;;oBAED,MAAM;;;;;;;;;;YAEN,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":";;;AAuCiB,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"}

package/types/src/main.d.ts

@@ -7,7 +7,6 @@ declare class Configorama {
     foundVariables: any[];
     fileRefsFound: any[];
     resolutionTracking: {};
-    _trackCalls: boolean;
     variableSyntax: RegExp;
     varPrefix: string;
     varSuffix: string;
@@ -65,7 +64,22 @@ declare class Configorama {
      * @returns {object} Metadata object containing variables, fileRefs, and summary
      */
     collectVariableMetadata(): object;
-    _cachedMetadata: any;
+    _cachedMetadata: {
+        variables: {};
+        uniqueVariables: {};
+        fileDependencies: {
+            globPatterns: any[];
+            dynamicPaths: any[];
+            resolvedPaths: any[];
+            byConfigPath: any[];
+            references: any[];
+        };
+        summary: {
+            totalVariables: number;
+            requiredVariables: number;
+            variablesWithDefaults: number;
+        };
+    };
     /**
      * Populate the variables in the given object.
      * @param objectToPopulate The object to populate variables within.

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

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/main.js"],"names":[],"mappings":";AA2GA;IACE,0CAieC;IAzdC,cAkBW;IAuBX,gBAAqB;IAErB,mCAAoC;IAEpC,sBAAwB;IACxB,qBAAuB;IAGvB,uBAA4B;IAE5B,qBAAmD;IAsBnD,uBAAoC;IAIpC,kBAAqC;IACrC,kBAAqC;IAErC,yBAA+F;IAC/F,yBAAuD;IACvD,kCAAyE;IAKvE,uBAAgD;IAKhD,YAAuB;IAEvB,oBAA0C;IAE1C,gBAAoD;IAOpD,uBAAkC;IAElC,uBAA8B;IAE9B,uBAAkC;IASpC,wBAAmC;IAGnC,mBAqHC;IAwED,4BAA8C;IAG9C,iCAAkC;IAalC,aA2EC;IAUD,oBAEC;IAGD,eAiDC;IAOD,YAAc;IACd,cAAgB;IAChB,kBAAkB;IAGpB;;;;OAIG;IACH,0BAHW,MAAM,GACJ,OAAO,CAQnB;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAOvB;IAED;;;;OAIG;IACH,gCAHW,MAAM,GACJ,OAAO,CA2BnB;IAKD;;;;;OAKG;IACH,oBAFa,OAAO,CAAC,GAAG,CAAC,CA6UxB;IA1UC,aAA4B;IAc1B,2BAA4B;IAmB1B,sBAA0C;IAC1C,4BAAkC;IA0SxC;;;OAGG;IACH,2BAFa,MAAM,CAsBlB;IAdC,qBAWE;IAIJ;;;;OAIG;IACH,uCAFa,OAAO,CAAC,GAAG,CAAC,CAIxB;IACD,+CAsBC;IAKD;;;;;;;;;;;;;;;;;;;OAmBG;IACH;;;;;;;;;;;OAWG;IACH,mFAHa;;;;cAZC,QAAQ;;;;eACR,IAAI,GAAC,MAAM,SAAO;OAWD,CA6E9B;IACD;;;OAGG;IACH;;;;;OAKG;IACH,oCAHa,OAAO,CAAC;;;;cAjGP,QAAQ;;;;eACR,IAAI,GAAC,MAAM,SAAO;OAgGgB,CAAC,EAAE,CA6BlD;IACD;;;;;OAKG;IACH,iDAFa,OAAO,CAAC,IAAI,CAAC,CAWzB;IAID;;;;;OAKG;IACH;;;;OAIG;IACH,2BAFa,eAAc;;;;;;;;;;OAAa,CAavC;IACD;;;;;OAKG;IACH,yBAHW;;;;;;;;;;OAAa,gCACX,cAAS,CAOrB;IACD;;;;;;OAMG;IACH,6DAFa,GAAC,CAiLb;IAKD;;;;;;;OAOG;IACH,yDAHa,OAAO,CAAC,GAAG,CAAC,CAiCxB;IACD;;;;OAIG;IAOH;;;;;;OAMG;IACH,wFA2BC;IACD;;;;;;;;;;;OAWG;IACH,8BARG;QAAyB,KAAK,EAAtB,GAAG;QACoB,IAAI,GAA3B,MAAM,EAAE;QACa,cAAc,GAAnC,MAAM;QACc,iBAAiB;KAC7C,6CAEU;QAAC,KAAK,EAAE,GAAG,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAC;QAAC,iBAAiB,CAAC,QAAQ;QAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAC,CAsa9J;IAID;;;;;;;;OAQG;IACH,qEAHa,OAAO,CAAC,GAAG,CAAC,CAoExB;IAKD;;;;;;;OAOG;IACH,0FAFa,OAAO,CAAC,GAAG,CAAC,CAgiBxB;IACD,+EA+BC;IACD,yDAiBC;IACD,oEA6BC;IAKD,8CAQC;IACD,kDAyBC;IACD;;;;;;;;;;;;;OAaG;IACH,wEAoDC;IAKD,4BAOC;IACD,sCAqEC;CACF"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/main.js"],"names":[],"mappings":";AA0GA;IACE,0CA2dC;IAndC,cAcW;IAuBX,gBAAqB;IAErB,mCAAoC;IAEpC,sBAAwB;IACxB,qBAAuB;IAGvB,uBAA4B;IAsB5B,uBAAoC;IAIpC,kBAAqC;IACrC,kBAAqC;IAErC,yBAA+F;IAC/F,yBAAuD;IACvD,kCAAyE;IAKvE,uBAAgD;IAKhD,YAAuB;IAEvB,oBAA0C;IAE1C,gBAAoD;IAOpD,uBAAkC;IAElC,uBAA8B;IAE9B,uBAAkC;IASpC,wBAAmC;IAGnC,mBAqHC;IAwED,4BAA8C;IAG9C,iCAAkC;IAalC,aA2EC;IAUD,oBAEC;IAGD,eAiDC;IAOD,YAAc;IACd,cAAgB;IAChB,kBAAkB;IAGpB;;;;OAIG;IACH,0BAHW,MAAM,GACJ,OAAO,CAQnB;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAOvB;IAED;;;;OAIG;IACH,gCAHW,MAAM,GACJ,OAAO,CA2BnB;IAKD;;;;;OAKG;IACH,oBAFa,OAAO,CAAC,GAAG,CAAC,CA6vBxB;IA1vBC,aAA4B;IAc1B,2BAA4B;IAmB1B,sBAA0C;IAC1C,4BAAkC;IA0tBxC;;;OAGG;IACH,2BAFa,MAAM,CA6alB;IAvBC;;;;;;;;;;;;;;;MAoBC;IAIH;;;;OAIG;IACH,uCAFa,OAAO,CAAC,GAAG,CAAC,CAIxB;IACD,+CAsBC;IAKD;;;;;;;;;;;;;;;;;;;OAmBG;IACH;;;;;;;;;;;OAWG;IACH,mFAHa;;;;cAZC,QAAQ;;;;eACR,IAAI,GAAC,MAAM,SAAO;OAWD,CA6E9B;IACD;;;OAGG;IACH;;;;;OAKG;IACH,oCAHa,OAAO,CAAC;;;;cAjGP,QAAQ;;;;eACR,IAAI,GAAC,MAAM,SAAO;OAgGgB,CAAC,EAAE,CA6BlD;IACD;;;;;OAKG;IACH,iDAFa,OAAO,CAAC,IAAI,CAAC,CAWzB;IAID;;;;;OAKG;IACH;;;;OAIG;IACH,2BAFa,eAAc;;;;;;;;;;OAAa,CAavC;IACD;;;;;OAKG;IACH,yBAHW;;;;;;;;;;OAAa,gCACX,cAAS,CAOrB;IACD;;;;;;OAMG;IACH,6DAFa,GAAC,CAiLb;IAKD;;;;;;;OAOG;IACH,yDAHa,OAAO,CAAC,GAAG,CAAC,CAiCxB;IACD;;;;OAIG;IAOH;;;;;;OAMG;IACH,wFA2BC;IACD;;;;;;;;;;;OAWG;IACH,8BARG;QAAyB,KAAK,EAAtB,GAAG;QACoB,IAAI,GAA3B,MAAM,EAAE;QACa,cAAc,GAAnC,MAAM;QACc,iBAAiB;KAC7C,6CAEU;QAAC,KAAK,EAAE,GAAG,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAC;QAAC,iBAAiB,CAAC,QAAQ;QAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAC,CAsa9J;IAID;;;;;;;;OAQG;IACH,qEAHa,OAAO,CAAC,GAAG,CAAC,CAoExB;IAKD;;;;;;;OAOG;IACH,0FAFa,OAAO,CAAC,GAAG,CAAC,CAiiBxB;IACD,+EA+BC;IACD,yDAiBC;IACD,oEA6BC;IAKD,8CAQC;IACD,kDAyBC;IACD;;;;;;;;;;;;;OAaG;IACH,wEAoDC;IAKD,4BAOC;IACD,sCAqEC;CACF"}

package/types/src/resolvers/valueFromGit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"valueFromGit.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromGit.js"],"names":[],"mappings":"AA4XiB;;;;;;;;EAUhB"}
+{"version":3,"file":"valueFromGit.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromGit.js"],"names":[],"mappings":"AA2XiB;;;;;;;;EAUhB"}

package/types/src/resolvers/valueFromSelf.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=valueFromSelf.d.ts.map

package/types/src/resolvers/valueFromSelf.d.ts.map

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

package/types/src/utils/parsing/parse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../src/utils/parsing/parse.js"],"names":[],"mappings":";;;;cA4Dc,MAAM;;;;cACN,MAAM;;;;eACN,MAAM;;;;kBACN,cAAe;;;;;;eAyIf,MAAM;;;;kBACN,cAAe;;AA/I7B;;;;;;GAMG;AAEH;;;;GAIG;AACH,iFAHW,YAAY,OAgItB;AAED;;;;GAIG;AAEH;;;;;GAKG;AACH,oCAJW,MAAM,SACN,gBAAgB,OAW1B"}
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../src/utils/parsing/parse.js"],"names":[],"mappings":";;;;cAgBc,MAAM;;;;cACN,MAAM;;;;eACN,MAAM;;;;kBACN,cAAe;;;;;;eAmIf,MAAM;;;;kBACN,cAAe;;AAzI7B;;;;;;GAMG;AAEH;;;;GAIG;AACH,iFAHW,YAAY,OA0HtB;AAED;;;;GAIG;AAEH;;;;;GAKG;AACH,oCAJW,MAAM,SACN,gBAAgB,OAW1B"}

package/types/src/utils/paths/findLineForKey.d.ts

@@ -9,13 +9,4 @@
  * @returns {number} Line number (1-indexed) or 0 if not found
  */
 export function findLineForKey(keyToFind: string, lines: string[], fileType: string): number;
-/**
- * Walk a dot-separated config path through raw file lines to find the exact line.
- * YAML uses indentation-based nesting, JSON uses brace-based nesting.
- * @param {string} configPath - Dot-separated path (e.g. 'resources.Parameters.Description')
- * @param {string[]} lines - Array of file lines
- * @param {string} fileType - File extension (e.g., '.yml', '.json')
- * @returns {number} Line number (1-indexed) or 0 if not found
- */
-export function findLineByPath(configPath: string, lines: string[], fileType: string): number;
 //# sourceMappingURL=findLineForKey.d.ts.map

package/types/src/utils/paths/findLineForKey.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findLineForKey.d.ts","sourceRoot":"","sources":["../../../../src/utils/paths/findLineForKey.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;GAMG;AACH,0CALW,MAAM,SACN,MAAM,EAAE,YACR,MAAM,GACJ,MAAM,CAiClB;AAED;;;;;;;GAOG;AACH,2CALW,MAAM,SACN,MAAM,EAAE,YACR,MAAM,GACJ,MAAM,CAYlB"}
+{"version":3,"file":"findLineForKey.d.ts","sourceRoot":"","sources":["../../../../src/utils/paths/findLineForKey.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;GAMG;AACH,0CALW,MAAM,SACN,MAAM,EAAE,YACR,MAAM,GACJ,MAAM,CAiClB"}

package/types/src/utils/strings/replaceAll.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"replaceAll.d.ts","sourceRoot":"","sources":["../../../../src/utils/strings/replaceAll.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH,wCALW,MAAM,YACN,MAAM,UACN,MAAM,GACJ,MAAM,CAelB"}
+{"version":3,"file":"replaceAll.d.ts","sourceRoot":"","sources":["../../../../src/utils/strings/replaceAll.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,wCALW,MAAM,YACN,MAAM,UACN,MAAM,GACJ,MAAM,CAelB"}

package/types/src/display.d.ts

@@ -1,62 +0,0 @@
-/**
- * Display "No Variables Found" message
- * @param {string} configFilePath
- * @param {RegExp} variableSyntax
- * @param {Object} variableTypes
- */
-export function displayNoVariablesFound(configFilePath: string, variableSyntax: RegExp, variableTypes: any): void;
-/**
- * Display variable details in stacked box format
- * @param {Object} params
- * @param {string[]} params.varKeys
- * @param {Object} params.variableData
- * @param {Object} params.uniqueVariables
- * @param {RegExp} params.varPrefixPattern
- * @param {RegExp} params.varSuffixPattern
- * @param {string[]} params.lines
- * @param {string} params.fileType
- * @param {string} params.configFilePath
- */
-export function displayVariableDetails({ varKeys, variableData, uniqueVariables, varPrefixPattern, varSuffixPattern, lines, fileType, configFilePath }: {
-    varKeys: string[];
-    variableData: any;
-    uniqueVariables: any;
-    varPrefixPattern: RegExp;
-    varSuffixPattern: RegExp;
-    lines: string[];
-    fileType: string;
-    configFilePath: string;
-}): void;
-/**
- * Display unique variables in stacked box format
- * @param {Object} params
- * @param {string[]} params.uniqueVarKeys
- * @param {Object} params.uniqueVariables
- * @param {string[]} params.lines
- * @param {string} params.fileType
- * @param {string} params.configFilePath
- */
-export function displayUniqueVariables({ uniqueVarKeys, uniqueVariables, lines, fileType, configFilePath }: {
-    uniqueVarKeys: string[];
-    uniqueVariables: any;
-    lines: string[];
-    fileType: string;
-    configFilePath: string;
-}): void;
-/**
- * Display configurable variables grouped by source type
- * @param {Object} params
- * @param {string[]} params.uniqueVarKeys
- * @param {Object} params.uniqueVariables
- * @param {string[]} params.lines
- * @param {string} params.fileType
- * @param {string} params.configFilePath
- */
-export function displayConfigurableVariables({ uniqueVarKeys, uniqueVariables, lines, fileType, configFilePath }: {
-    uniqueVarKeys: string[];
-    uniqueVariables: any;
-    lines: string[];
-    fileType: string;
-    configFilePath: string;
-}): void;
-//# sourceMappingURL=display.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"display.d.ts","sourceRoot":"","sources":["../../src/display.js"],"names":[],"mappings":"AAcA;;;;;GAKG;AACH,wDAJW,MAAM,kBACN,MAAM,4BAwBhB;AAED;;;;;;;;;;;GAWG;AACH,wJATG;IAAyB,OAAO,EAAxB,MAAM,EAAE;IACO,YAAY;IACZ,eAAe;IACf,gBAAgB,EAA/B,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACW,KAAK,EAAtB,MAAM,EAAE;IACO,QAAQ,EAAvB,MAAM;IACS,cAAc,EAA7B,MAAM;CAChB,QAyJA;AAED;;;;;;;;GAQG;AACH,4GANG;IAAyB,aAAa,EAA9B,MAAM,EAAE;IACO,eAAe;IACb,KAAK,EAAtB,MAAM,EAAE;IACO,QAAQ,EAAvB,MAAM;IACS,cAAc,EAA7B,MAAM;CAChB,QAiHA;AAED;;;;;;;;GAQG;AACH,kHANG;IAAyB,aAAa,EAA9B,MAAM,EAAE;IACO,eAAe;IACb,KAAK,EAAtB,MAAM,EAAE;IACO,QAAQ,EAAvB,MAAM;IACS,cAAc,EAA7B,MAAM;CAChB,QAyIA"}

package/types/src/metadata.d.ts

@@ -1,26 +0,0 @@
-/**
- * Collect metadata about all variables found in the configuration
- * @param {Object} params
- * @param {RegExp} params.variableSyntax
- * @param {Object} params.variablesKnownTypes
- * @param {Object} params.variableTypes
- * @param {RegExp|null} params.filterMatch
- * @param {string} params.configFilePath
- * @param {Object} params.displayConfig - rawOriginalConfig || originalConfig, used for traversal
- * @param {Object} params.originalConfig - this.originalConfig, used for dotProp.get checks
- * @param {string} params.varSuffix
- * @param {RegExp} params.varSuffixWithSpacePattern
- * @returns {Object} Metadata object containing variables, fileDependencies, and summary
- */
-export function collectVariableMetadata({ variableSyntax, variablesKnownTypes, variableTypes, filterMatch, configFilePath, displayConfig, originalConfig, varSuffix, varSuffixWithSpacePattern, }: {
-    variableSyntax: RegExp;
-    variablesKnownTypes: any;
-    variableTypes: any;
-    filterMatch: RegExp | null;
-    configFilePath: string;
-    displayConfig: any;
-    originalConfig: any;
-    varSuffix: string;
-    varSuffixWithSpacePattern: RegExp;
-}): any;
-//# sourceMappingURL=metadata.d.ts.map