configorama 0.10.0 → 0.10.3

package/README.md

@@ -356,9 +356,9 @@ Resolution is a **fixed-point loop**: each pass resolves what it can, then `popu
 
 ### Performance
 
-Configorama is fast and stays out of the way at runtime — a typical 21KB serverless-style config resolves in **~3ms** on warm Node 22.
+A typical 21KB serverless-style config resolves in **~3ms** on warm Node 22.
 
-- Honest before/after benchmarks against the published `0.9.17` baseline: [`PERF.md`](./PERF.md)
+- Before/after benchmarks against the published `0.9.17` baseline: [`PERF.md`](./PERF.md)
 - Reproducible bench harness: [`scripts/bench.js`](./scripts/bench.js)
 - Run against your own configs:
   ```bash
@@ -366,7 +366,7 @@ Configorama is fast and stays out of the way at runtime — a typical 21KB serve
   node scripts/bench.js /path/to/another/configorama  # A/B
   ```
 
-If your config is slow, please open an issue with the config (or a redacted reproduction) — we can profile and tighten the hot path.
+If your config is slow, please open an issue with the config (or a redacted reproduction). We're happy to profile and tighten the hot path.
 
 ---
 
@@ -1363,7 +1363,7 @@ inRange: ${between(${value}, 50, 100)}  # true
 
 ## Bundled Plugins
 
-Plugins ship in the repo under `plugins/` and are opt-in — install their peer dependencies, then wire them into `variableSources`. Plugins are *not* required dependencies of `configorama` itself, so consumers who don't need them aren't paying for them.
+Plugins ship in the repo under `plugins/` and are opt-in: install their peer dependencies, then wire them into `variableSources`. Plugins are *not* required dependencies of `configorama` itself, so consumers who don't need them aren't paying for them.
 
 ### CloudFormation
 
@@ -1393,7 +1393,7 @@ const config = await configorama('config.yml', {
 })
 ```
 
-Full docs: [`plugins/cloudformation/README.md`](./plugins/cloudformation/README.md) — covers the env-var-prefix alias convention, refcounted credential mutex for parallel-safe deploys, and the `skipResolution` mode for CI metadata extraction.
+Full docs: [`plugins/cloudformation/README.md`](./plugins/cloudformation/README.md). Covers the env-var-prefix alias convention, the refcounted credential mutex for parallel-safe deploys, and the `skipResolution` mode for CI metadata extraction.
 
 Peer dependency (install separately):
 
@@ -1590,7 +1590,7 @@ const { format } = require('configorama')
 // Parse YAML
 const yamlObj = format.yaml.parse('key: value')
 
-// Parse JSON (handles JSON5/JSONC too — comments, trailing commas)
+// Parse JSON (handles JSON5/JSONC too: comments, trailing commas)
 const jsonObj = format.json.parse('{ key: "value", }')
 
 // Parse TOML
@@ -1605,7 +1605,7 @@ const hclObj = await format.hcl.parse('variable "example" { default = "value" }'
 
 **Available parsers:** `format.json`, `format.yaml`, `format.toml`, `format.ini`, `format.hcl`, `format.markdown`.
 
-Each has at minimum a `parse(content)` method; `dump(obj)` / `stringify(obj)` and cross-format converters (e.g. `format.yaml.toJson`, `format.toml.toYaml`) are available where the underlying format supports them. `format.markdown` is a frontmatter parser — see [Markdown Files](#markdown-files) below.
+Each has at minimum a `parse(content)` method; `dump(obj)` / `stringify(obj)` and cross-format converters (e.g. `format.yaml.toJson`, `format.toml.toYaml`) are available where the underlying format supports them. `format.markdown` is a frontmatter parser; see [Markdown Files](#markdown-files) below.
 
 **Real use cases for `format`:**
 
@@ -1644,7 +1644,7 @@ Resolves to:
 }
 ```
 
-The body is detached during variable resolution (so `${…}` inside the body text is left alone) and re-attached afterward — only frontmatter keys get variable expansion.
+The body is detached during variable resolution (so `${…}` inside the body text is left alone) and re-attached afterward; only frontmatter keys get variable expansion.
 
 ---
 
@@ -1667,7 +1667,7 @@ const config = await configorama('config.yml', { syntax })
 |---|---|---|---|
 | `prefix` | `string` | `'${'` | Opening delimiter |
 | `suffix` | `string` | `'}'` | Closing delimiter |
-| `excludePatterns` | `string[]` | `['AWS', 'stageVariables']` | Patterns to exclude via negative lookahead (so e.g. `${AWS::Region}` is left untouched by CloudFormation users) |
+| `excludePatterns` | `string[]` | `['AWS', 'aws:', 'stageVariables']` | Patterns to exclude via negative lookahead (so e.g. `${AWS::Region}` and `${aws:username}` are left untouched by CloudFormation users) |
 
 ---
 
@@ -1762,7 +1762,7 @@ buildVariableSyntax('<', '>')      // <env:FOO>
 function buildVariableSyntax(
   prefix: string = '${',
   suffix: string = '}',
-  excludePatterns: string[] = ['AWS', 'stageVariables']
+  excludePatterns: string[] = ['AWS', 'aws:', 'stageVariables']
 ): string
 ```
 
@@ -1821,7 +1821,7 @@ const config = await configorama(configFile, {
 - Serverless Framework integration (let the framework resolve SSM and other refs it owns)
 - Gradual migration (allow unknown types during transition period)
 
-> CloudFormation refs (`${cf:…}`, `${cf(region):…}`, `${cf(account:region):…}`) are now resolved natively by the bundled [`plugins/cloudformation/`](./plugins/cloudformation/README.md) plugin — no external resolver required.
+> CloudFormation refs (`${cf:…}`, `${cf(region):…}`, `${cf(account:region):…}`) are now resolved natively by the bundled [`plugins/cloudformation/`](./plugins/cloudformation/README.md) plugin; no external resolver required.
 
 ---
 
@@ -1891,6 +1891,9 @@ const config = await configorama(configFile, {
 | `allowUnknownVariableTypes` | `boolean \| string[]` | `false` | Allow unknown variable types to pass through |
 | `allowUnresolvedVariables` | `boolean \| string[]` | `false` | Allow known types that can't resolve to pass through |
 | `allowUndefinedValues` | `boolean` | `false` | Allow undefined as a valid end result |
+| `ignorePaths` | `string[]` | Built-in CloudFormation/code paths | Glob-like config paths whose values should be left verbatim |
+| `skipResolutionPaths` | `string[]` | `[]` | Alias for `ignorePaths` |
+| `disableDefaultIgnorePaths` | `boolean` | `false` | Disable the built-in CloudFormation/code ignore paths |
 | `returnMetadata` | `boolean` | `false` | Return `{ config, metadata }` instead of just the resolved config |
 | `returnPreResolvedVariableDetails` | `boolean` | `false` | Return metadata about variables *without* resolving them (used by `analyze()`) |
 | `useDotEnvFiles` | `boolean` | `false` | Auto-load `.env`, `.env.{stage}`, etc. into `process.env` before resolution (via [env-stage-loader](https://www.npmjs.com/package/env-stage-loader)) |
@@ -1900,7 +1903,7 @@ const config = await configorama(configFile, {
 | `mergeKeys` | `string[]` | `[]` | Keys to merge in arrays of objects |
 | `filePathOverrides` | `Record<string, string>` | `{}` | Map of file paths to override (for testing/mocking) |
 
-> The config file itself can also set `useDotenv: true` (or `useDotEnv: true`) at the top level to trigger dotenv loading — useful if you want the behavior intrinsic to the config rather than the JS caller.
+> The config file itself can also set `useDotenv: true` (or `useDotEnv: true`) at the top level to trigger dotenv loading. Useful when you want the behavior intrinsic to the config rather than the JS caller.
 
 **Legacy options (deprecated):**
 
@@ -2051,7 +2054,7 @@ const config = await configorama('config.yml', {
 })
 ```
 
-> **See also:** the bundled [`plugins/cloudformation/`](./plugins/cloudformation/README.md) plugin is a production-grade example of a `source: 'remote'` resolver — it handles multi-region, multi-account credential swapping, and per-instance client/output caching.
+> **See also:** the bundled [`plugins/cloudformation/`](./plugins/cloudformation/README.md) plugin is a working example of a `source: 'remote'` resolver. It handles multi-region and multi-account credential swapping, plus per-instance client and output caching.
 
 ```yaml
 # config.yml
@@ -2084,8 +2087,14 @@ configorama config.yml --info
 # Verify config (check for errors without resolving)
 configorama config.yml --verify
 
-# Extract specific path from config
-configorama config.yml database.host
+# Extract a specific path from config
+configorama config.yml .database.host
+
+# Print an extracted scalar without JSON quotes
+configorama config.yml .database.host --raw
+
+# Copy the formatted output to your clipboard
+configorama config.yml .database.host --raw --copy
 
 # Output as YAML
 configorama config.yml --format yaml
@@ -2102,6 +2111,8 @@ Options:
   -v, --version             Show version number
   -o, --output <file>       Write output to file instead of stdout
   -f, --format <format>     Output format: json, yaml, or js (default: json)
+  -r, --raw                 Print extracted scalar values without JSON quoting
+  -c, --copy                Copy the formatted output to the clipboard
   -d, --debug               Enable debug mode
   -i, --info                Show info about the config
   -V, --verify              Verify the config
@@ -2110,10 +2121,24 @@ Options:
   --allow-undefined         Allow undefined values in the final output
 
 Path Extraction:
-  configorama config.yml database.host    Extract specific value
-  configorama config.yml functions[0]     Extract from array
+  configorama config.yml .database.host   Extract a nested value
+  configorama config.yml '.functions[0]'  Extract from an array
+  configorama -r config.yml .stage        Print raw scalar output
+  configorama -r -c config.yml .stage     Print and copy raw scalar output
 ```
 
+Path extraction uses jq-style paths. JSON remains the default output format, so extracted strings are quoted by default:
+
+```bash
+configorama config.yml .stage
+# "prod"
+
+configorama config.yml .stage --raw
+# prod
+```
+
+`--copy` copies exactly the formatted value that the CLI prints. It uses native clipboard commands where available: `pbcopy` on macOS, `clip` on Windows, and `wl-copy`, `xclip`, or `xsel` on Linux.
+
 ### CLI Examples
 
 **Basic resolution:**
@@ -2151,12 +2176,20 @@ database:
   host: localhost
   port: 5432
 
-# Extract database.host
-configorama config.yml database.host
+# Extract database.host as JSON
+configorama config.yml .database.host
+# Output: "localhost"
+
+# Extract database.host as a raw scalar
+configorama config.yml .database.host --raw
+# Output: localhost
+
+# Extract and copy the raw scalar
+configorama config.yml .database.host --raw --copy
 # Output: localhost
 
 # Extract database config as JSON
-configorama config.yml database --format json
+configorama config.yml .database --format json
 # Output: {"host":"localhost","port":5432}
 ```
 
@@ -2216,7 +2249,7 @@ configorama config.yml --allow-unknown
 **Allow undefined values in the final output:**
 
 ```bash
-# Don't error on values that resolved to undefined — emit them as nulls
+# Don't error on values that resolved to undefined; emit them as nulls
 # (useful for downstream tooling that does its own validation)
 configorama config.yml --allow-undefined
 ```
@@ -2863,7 +2896,7 @@ const fullyResolved = await externalResolver(partiallyResolved)
 
 **Use case:** Serverless Framework + Serverless Dashboard workflow.
 
-> For CloudFormation refs specifically, the bundled [CF plugin](./plugins/cloudformation/README.md) resolves them natively in Stage 1 — you don't need a second pass.
+> For CloudFormation refs specifically, the bundled [CF plugin](./plugins/cloudformation/README.md) resolves them natively in Stage 1, so you don't need a second pass.
 
 ---
 
@@ -3000,11 +3033,11 @@ timeout: ${selectByEnv(30, 5, ${environment})}
 
 ## Comparison vs Serverless Framework Variables
 
-Configorama was forked from the Serverless Framework variable system and extended. Here's what's different:
+Configorama was forked from the Serverless Framework variable system and extended. The differences:
 
 | Capability | Serverless | Configorama |
 |---|---|---|
-| Framework-agnostic — use outside Serverless | ❌ Serverless-only | ✅ Any tool, any framework |
+| Framework-agnostic; use outside Serverless | ❌ Serverless-only | ✅ Any tool, any framework |
 | Pluggable variable sources | ❌ Hardcoded | ✅ Custom resolvers, custom syntax |
 | `self:` prefix optional in self-refs | ❌ Required | ✅ `${foo.bar}` works without `self:` |
 | Numbers as defaults | ❌ Coerced to string | ✅ `${env:TIMEOUT, 30}` stays numeric |
@@ -3067,7 +3100,7 @@ MIT © [David Wells](https://davidwells.io)
 
 ## Contributing
 
-Bug reports and reproductions are very welcome — please open an [issue](https://github.com/DavidWells/configorama/issues) with a minimal failing config. PRs are reviewed case-by-case; small targeted fixes with a test case are most likely to land quickly.
+Bug reports and reproductions are very welcome. Please open an [issue](https://github.com/DavidWells/configorama/issues) with a minimal failing config. PRs are reviewed case-by-case; small targeted fixes with a test case are most likely to land quickly.
 
 ## Support
 

package/cli.js

@@ -2,6 +2,7 @@
 
 const fs = require('fs')
 const minimist = require('minimist')
+const { spawnSync } = require('child_process')
 const Configorama = require('./src/main')
 const deepLog = require('./src/utils/ui/deep-log')
 const { logHeader } = require('./src/utils/ui/logs')
@@ -12,13 +13,15 @@ const getValueAtPath = require('./src/utils/parsing/getValueAtPath')
 // Parse command line arguments
 const argv = minimist(process.argv.slice(2), {
   string: ['output', 'o', 'format', 'f', 'param'],
-  boolean: ['help', 'h', 'version', 'v', 'V', 'debug', 'allow-unknown', 'allow-undefined', 'list', 'info', 'verify'],
+  boolean: ['help', 'h', 'version', 'v', 'V', 'debug', 'allow-unknown', 'allow-undefined', 'list', 'info', 'verify', 'raw', 'r', 'copy', 'c'],
   alias: {
     h: 'help',
     v: 'version',
     V: 'verify',
     o: 'output',
     f: 'format',
+    r: 'raw',
+    c: 'copy',
     l: 'list',
     i: 'info',
   },
@@ -40,6 +43,8 @@ Options:
   -v, --version             Show version number
   -o, --output <file>       Write output to file instead of stdout
   -f, --format <format>     Output format: json, yaml, or js (default: json)
+  -r, --raw                 Print extracted scalar values without JSON quoting
+  -c, --copy                Copy the formatted output to the clipboard
   -d, --debug               Enable debug mode
   -i, --info                Show info about the config
   -V, --verify              Verify the config
@@ -62,6 +67,8 @@ Path Extraction:
 Examples:
   configorama config.yml
   configorama config.yml .database.host
+  configorama -r config.yml .database.host
+  configorama -r --copy config.yml .database.host
   configorama '.servers[0].port' config.yml
   configorama --info config.yml
   configorama --format yaml config.json
@@ -84,11 +91,53 @@ if (argv.version) {
 let inputFile = null
 let extractPath = null
 
+function isFileArg(arg) {
+  if (fs.existsSync(arg) && fs.statSync(arg).isFile()) return true
+  return arg.startsWith('./') || arg.startsWith('../')
+}
+
+function getClipboardCommands() {
+  if (process.env.CONFIGORAMA_CLIPBOARD_COMMAND) {
+    return [{ command: process.env.CONFIGORAMA_CLIPBOARD_COMMAND, shell: true }]
+  }
+
+  if (process.platform === 'darwin') return [{ command: 'pbcopy', args: [] }]
+  if (process.platform === 'win32') return [{ command: 'clip', args: [] }]
+
+  return [
+    { command: 'wl-copy', args: [] },
+    { command: 'xclip', args: ['-selection', 'clipboard'] },
+    { command: 'xsel', args: ['--clipboard', '--input'] }
+  ]
+}
+
+function copyToClipboard(value) {
+  let lastError = ''
+  for (const candidate of getClipboardCommands()) {
+    const result = spawnSync(candidate.command, candidate.args || [], {
+      input: String(value),
+      encoding: 'utf8',
+      shell: !!candidate.shell,
+      stdio: ['pipe', 'ignore', 'pipe']
+    })
+
+    if (!result.error && result.status === 0) return { ok: true }
+    lastError = result.error ? result.error.message : (result.stderr || '').trim()
+  }
+
+  return {
+    ok: false,
+    error: lastError || 'No supported clipboard command found'
+  }
+}
+
 for (const arg of argv._) {
   if (arg === 'setup') continue
 
   // jq-style paths start with '.' or '['
-  if (arg.startsWith('.') || arg.startsWith('[')) {
+  if (!inputFile && isFileArg(arg)) {
+    inputFile = arg
+  } else if (arg.startsWith('.') || arg.startsWith('[')) {
     extractPath = arg
   } else if (!inputFile) {
     inputFile = arg
@@ -134,6 +183,10 @@ const {
   l,
   info,
   i,
+  r,
+  raw,
+  c,
+  copy,
   'allow-unknown': allowUnknown, 
   'allow-undefined': allowUndefined,
   'allow-unknown-file-refs': allowUnknownFileRefs,
@@ -177,7 +230,9 @@ configorama(inputFile, options)
     let output
 
     // Format the output
-    switch (argv.format.toLowerCase()) {
+    if (argv.raw && extractPath && (config === null || ['string', 'number', 'boolean'].includes(typeof config))) {
+      output = config === null ? 'null' : String(config)
+    } else switch (argv.format.toLowerCase()) {
       case 'yaml':
       case 'yml':
         const YAML = require('./src/parsers/yaml')
@@ -204,6 +259,14 @@ configorama(inputFile, options)
         output = JSON.stringify(config, null, 2)
     }
 
+    if (argv.copy) {
+      const copyResult = copyToClipboard(output)
+      if (!copyResult.ok) {
+        console.error(`Error: Unable to copy to clipboard: ${copyResult.error}`)
+        process.exit(1)
+      }
+    }
+
     // Write to file or stdout
     if (argv.output) {
       fs.writeFileSync(argv.output, output)
@@ -230,4 +293,4 @@ configorama(inputFile, options)
       console.error('error', error)
     }
     process.exit(1)
-  })
+  })

package/index.d.ts

@@ -38,6 +38,18 @@ interface ConfigoramaSettings {
   /** Allow undefined values as final results */
   allowUndefinedValues?: boolean
 
+  /**
+   * Glob-like config paths whose values should be left verbatim.
+   * Useful for embedded languages that also use ${...}.
+   */
+  ignorePaths?: string[]
+
+  /** Alias for ignorePaths */
+  skipResolutionPaths?: string[]
+
+  /** Disable the built-in CloudFormation and embedded-code ignore paths */
+  disableDefaultIgnorePaths?: boolean
+
   // === Legacy Options (deprecated, use above instead) ===
 
   /** @deprecated Use allowUnknownVariableTypes instead */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "configorama",
-  "version": "0.10.0",
+  "version": "0.10.3",
   "description": "Variable support for configuration files",
   "main": "src/index.js",
   "types": "index.d.ts",

package/src/index.js

@@ -13,6 +13,9 @@ const { buildVariableSyntax } = require('./utils/variables/variableUtils')
  * @property {Object.<string, Function>} [functions] - Object of custom functions
  * @property {boolean} [allowUnknownVars] - allow unknown variables to pass through without throwing errors
  * @property {boolean} [allowUndefinedValues] - allow undefined values to pass through without throwing errors
+ * @property {string[]} [ignorePaths] - glob-like config paths whose values should be left verbatim
+ * @property {string[]} [skipResolutionPaths] - alias for ignorePaths
+ * @property {boolean} [disableDefaultIgnorePaths] - disable built-in CloudFormation and embedded-code ignore paths
  * @property {Object|Function} [dynamicArgs] - values passed into .js config files if user using javascript config
  * @property {boolean} [returnMetadata] - return both config and metadata about variables found
  * @property {boolean} [dotEnvSilent] - suppress env-stage-loader logs when useDotenv/useDotEnv is enabled

package/src/main.js

@@ -60,6 +60,7 @@ const { mergeByKeys } = require('./utils/parsing/mergeByKeys')
 const { arrayToJsonPath } = require('./utils/parsing/arrayToJsonPath')
 /* Utils - paths */
 const { findLineByPath } = require('./utils/paths/findLineForKey')
+const { normalizeIgnorePaths, compileIgnorePaths, shouldIgnorePath } = require('./utils/paths/ignorePaths')
 /* Utils - regex */
 const { combineRegexes, funcRegex, fileRefSyntax, textRefSyntax } = require('./utils/regex')
 /* Utils - strings */
@@ -162,6 +163,11 @@ class Configorama {
       // CLI users can still see them with --verbose or dotEnvSilent: false.
       dotEnvSilent: !VERBOSE,
       dotEnvDebug: false,
+      // Glob-like path patterns whose values should be left verbatim.
+      // Useful for embedded languages that also use ${...}, such as
+      // CloudFormation Fn::Sub, inline Lambda code, and CloudFront functions.
+      ignorePaths: [],
+      skipResolutionPaths: [],
     }, options)
 
     // Backward compat: allowUnknownVars -> allowUnknownVariableTypes
@@ -221,9 +227,10 @@ class Configorama {
 
     // Use $[...] syntax for HCL/Terraform files to avoid conflicts with Terraform's ${} syntax
     const isHclFile = detectedFileType === '.tf' || detectedFileType === '.hcl'
+    const defaultExcludedPatterns = ['AWS', 'aws:', 'stageVariables']
     const defaultSyntax = isHclFile
-      ? buildVariableSyntax('$[', ']', ['AWS', 'stageVariables'])
-      : buildVariableSyntax('${', '}', ['AWS', 'stageVariables'])
+      ? buildVariableSyntax('$[', ']', defaultExcludedPatterns)
+      : buildVariableSyntax('${', '}', defaultExcludedPatterns)
 
     const varSyntax = options.syntax || defaultSyntax
     let varRegex
@@ -247,6 +254,7 @@ class Configorama {
     this.varPrefixPattern = new RegExp('^' + this.varPrefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
     this.varSuffixPattern = new RegExp(escapedSuffix + '$')
     this.varSuffixWithSpacePattern = new RegExp('\\s+' + escapedSuffix + '$')
+    this.ignorePathPatterns = compileIgnorePaths(normalizeIgnorePaths(this.settings))
 
     // Set initial config object to populate
     if (typeof fileOrObject === 'object') {
@@ -1063,6 +1071,7 @@ class Configorama {
       originalConfig: this.originalConfig,
       varSuffix: this.varSuffix,
       varSuffixWithSpacePattern: this.varSuffixWithSpacePattern,
+      ignorePathPatterns: this.ignorePathPatterns,
     })
 
     return this._cachedMetadata
@@ -1102,6 +1111,10 @@ class Configorama {
   // #######################
   // ## PROPERTY HANDLING ##
   // #######################
+  shouldSkipResolution(pathValue) {
+    return shouldIgnorePath(pathValue, this.ignorePathPatterns)
+  }
+
   /**
    * The declaration of a terminal property.  This declaration includes the path and value of the
    * property.
@@ -1259,6 +1272,11 @@ class Configorama {
       }
       return false
     })
+    /* Leave opaque paths verbatim. These often contain non-configorama
+       `${...}` syntax from CloudFormation, JavaScript, shell, VTL, etc. */
+    variables = variables.filter((property) => {
+      return !this.shouldSkipResolution(property.path)
+    })
     /*
     console.log(`variables at call count ${this.callCount}`, variables)
     /** */
@@ -1545,6 +1563,9 @@ class Configorama {
       console.log(valueObject)
     }
     const property = valueObject.value
+    if (this.shouldSkipResolution(valueObject.path)) {
+      return Promise.resolve(property)
+    }
     const matches = this.getMatches(property)
     /*
     console.log('populateValue matches', matches)

package/src/metadata.js

@@ -6,6 +6,7 @@ const fs = require('fs')
 const traverse = require('traverse')
 const dotProp = require('dot-prop')
 const { normalizePath, extractFilePath, resolveInnerVariables } = require('./utils/paths/filePathUtils')
+const { shouldIgnorePath } = require('./utils/paths/ignorePaths')
 const { findNestedVariables } = require('./utils/variables/findNestedVariables')
 const { splitOnPipe } = require('./utils/strings/splitOnPipe')
 
@@ -21,6 +22,7 @@ const { splitOnPipe } = require('./utils/strings/splitOnPipe')
  * @param {Object} params.originalConfig - this.originalConfig, used for dotProp.get checks
  * @param {string} params.varSuffix
  * @param {RegExp} params.varSuffixWithSpacePattern
+ * @param {string[][]} [params.ignorePathPatterns]
  * @returns {Object} Metadata object containing variables, fileDependencies, and summary
  */
 function collectVariableMetadata({
@@ -33,6 +35,7 @@ function collectVariableMetadata({
   originalConfig,
   varSuffix,
   varSuffixWithSpacePattern,
+  ignorePathPatterns,
 }) {
   const foundVariables = []
   const variableData = {}
@@ -46,8 +49,8 @@ function collectVariableMetadata({
   traverse(displayConfig).forEach(function (rawValue) {
     if (typeof rawValue === 'string' && rawValue.match(variableSyntax)) {
       const configValuePath = this.path.join('.')
-      /* Skip Fn::Sub variables */
-      if (configValuePath.endsWith('Fn::Sub')) {
+      /* Skip opaque paths that contain non-configorama ${...} syntax. */
+      if (shouldIgnorePath(this.path, ignorePathPatterns)) {
         return
       }
 

package/src/utils/parsing/parse.js

@@ -10,7 +10,7 @@ const { executeTypeScriptFileSync } = require('../../parsers/typescript')
 const { executeESMFileSync } = require('../../parsers/esm')
 const cloudFormationSchema = require('./cloudformationSchema')
 
-const DEFAULT_VAR_SYNTAX = '\\${((?!AWS|stageVariables)[ ~:a-zA-Z0-9=+!@#%*<>?._\'",|\\-\\/\\(\\)\\\\]+?)}'
+const DEFAULT_VAR_SYNTAX = '\\${((?!AWS|aws:|stageVariables)[ ~:a-zA-Z0-9=+!@#%*<>?._\'",|\\-\\/\\(\\)\\\\]+?)}'
 
 const KNOWN_EXTENSIONS = new Set([
   '.yml', '.yaml', '.json', '.json5', '.jsonc',

package/src/utils/paths/ignorePaths.js

@@ -0,0 +1,69 @@
+const DEFAULT_IGNORE_PATHS = [
+  '**.Fn::Sub',
+  '**.Properties.Code.ZipFile',
+  '**.Properties.FunctionCode',
+  '**.Properties.UserData',
+  '**.Properties.BuildSpec',
+  '**.Properties.DefinitionString',
+  '**.Properties.DefinitionBody',
+  '**.Properties.RequestMappingTemplate',
+  '**.Properties.ResponseMappingTemplate',
+  '**.Properties.RequestTemplates.*',
+  '**.Properties.ResponseTemplates.*',
+  '**.Metadata.AWS::CloudFormation::Init.*.files.*.content',
+  '**.Metadata.AWS::CloudFormation::Init.*.commands.*.command'
+]
+
+function toArray(value) {
+  if (!value) return []
+  return Array.isArray(value) ? value : [value]
+}
+
+function pathToSegments(pathValue) {
+  if (!pathValue) return []
+  return Array.isArray(pathValue) ? pathValue.map(String) : String(pathValue).split('.')
+}
+
+function patternToSegments(pattern) {
+  return String(pattern).split('.')
+}
+
+function matchSegments(patternSegments, pathSegments) {
+  if (!patternSegments.length) return pathSegments.length === 0
+
+  const [head, ...tail] = patternSegments
+  if (head === '**') {
+    if (matchSegments(tail, pathSegments)) return true
+    return pathSegments.length > 0 && matchSegments(patternSegments, pathSegments.slice(1))
+  }
+
+  if (!pathSegments.length) return false
+  if (head !== '*' && head !== pathSegments[0]) return false
+  return matchSegments(tail, pathSegments.slice(1))
+}
+
+function normalizeIgnorePaths(options = {}) {
+  const defaults = options.disableDefaultIgnorePaths ? [] : DEFAULT_IGNORE_PATHS
+  return Array.from(new Set([
+    ...defaults,
+    ...toArray(options.ignorePaths),
+    ...toArray(options.skipResolutionPaths)
+  ]))
+}
+
+function compileIgnorePaths(patterns) {
+  return toArray(patterns).map(patternToSegments)
+}
+
+function shouldIgnorePath(pathValue, compiledPatterns) {
+  if (!compiledPatterns || !compiledPatterns.length) return false
+  const pathSegments = pathToSegments(pathValue)
+  return compiledPatterns.some((patternSegments) => matchSegments(patternSegments, pathSegments))
+}
+
+module.exports = {
+  DEFAULT_IGNORE_PATHS,
+  normalizeIgnorePaths,
+  compileIgnorePaths,
+  shouldIgnorePath
+}

package/src/utils/strings/splitByComma.test.js

@@ -2,7 +2,7 @@ const { test } = require('uvu')
 const assert = require('uvu/assert')
 const { splitByComma } = require('./splitByComma')
 
-const variableSyntax = /\${((?!AWS|stageVariables)[ ~:a-zA-Z0-9=+!@#%*<>?._'",|\-\/\(\)\\]+?)}/g
+const variableSyntax = /\${((?!AWS|aws:|stageVariables)[ ~:a-zA-Z0-9=+!@#%*<>?._'",|\-\/\(\)\\]+?)}/g
 
 test('splitByComma - should return array with original string when no commas present', () => {
   const result = splitByComma('singleString')
@@ -145,4 +145,4 @@ test('splitByComma - should handle odd backslashes (escaped quote)', () => {
 })
 
 // Run all tests
-test.run() 
+test.run()

package/src/utils/variables/findNestedVariables.js

@@ -358,7 +358,7 @@ function findNestedVariablesOld(input, regex, variablesKnownTypes, debug = false
 }
 
 // // Test with the example
-// const regex = /\${((?!AWS|stageVariables)[ ~:a-zA-Z0-9=+!@#%*<>?._'",|\-\/\(\)\\]+?)}/g
+// const regex = /\${((?!AWS|aws:|stageVariables)[ ~:a-zA-Z0-9=+!@#%*<>?._'",|\-\/\(\)\\]+?)}/g
 // const input = '${file(./config.${opt:stage, ${defaultStage}}.json):CREDS}'
 
 // // Run the function with debug output
@@ -374,4 +374,4 @@ function findNestedVariablesOld(input, regex, variablesKnownTypes, debug = false
 
 module.exports = {
   findNestedVariables
-}
+}

package/src/utils/variables/findNestedVariables.test.js

@@ -9,7 +9,7 @@ const getValueFromOptions = require('../../resolvers/valueFromOptions')
 const getValueFromGit = require('../../resolvers/valueFromGit')
 
 // Define the regex pattern as used in the main function
-const regex = /\${((?!AWS|stageVariables)[ ~:a-zA-Z0-9=+!@#%*<>?._'",|\-\/\(\)\\]+?)}/g;
+const regex = /\${((?!AWS|aws:|stageVariables)[ ~:a-zA-Z0-9=+!@#%*<>?._'",|\-\/\(\)\\]+?)}/g;
 const variablesKnownTypes = /(^env:|^opt:|^self:|^file\((~?[\{\}\:\$a-zA-Z0-9._\-\/,'" ]+?)\)|^git:|(\${)?deep:\d+(\.[^}]+)*()}?)/
 
 const fileRefSyntax = RegExp(/^file\((~?[@\{\}\:\$a-zA-Z0-9._\-\/,'" ]+?)\)/g)
@@ -239,4 +239,4 @@ test('findNestedVariables - deep - no var types passed', () => {
 
 
 // Run all tests
-test.run(); 
+test.run();

package/src/utils/variables/variableUtils.js

@@ -93,10 +93,10 @@ Remove or update the \${${variableString}} to fix
  * Excludes suffix characters from the allowed set to prevent parsing issues
  * @param {string} [prefix='${'] - Variable prefix
  * @param {string} [suffix='}'] - Variable suffix
- * @param {string[]} [excludePatterns=['AWS', 'stageVariables']] - Patterns to exclude via negative lookahead
+ * @param {string[]} [excludePatterns=['AWS', 'aws:', 'stageVariables']] - Patterns to exclude via negative lookahead
  * @returns {string} Regex source string
  */
-function buildVariableSyntax(prefix = '${', suffix = '}', excludePatterns = ['AWS', 'stageVariables']) {
+function buildVariableSyntax(prefix = '${', suffix = '}', excludePatterns = ['AWS', 'aws:', 'stageVariables']) {
   // All allowed characters, stored as individual escaped entries for regex character class
   // Each entry is how it appears in a regex character class
   // NOTE: { and } are intentionally excluded - they break nested variable matching
@@ -145,4 +145,4 @@ module.exports = {
   getFallbackString,
   verifyVariable,
   buildVariableSyntax
-} 
+}

package/src/utils/variables/variableUtils.test.js

@@ -172,6 +172,15 @@ test('buildVariableSyntax - supports backslash in values', () => {
   assert.is(match[0], "${env:FOO, 'path\\to\\file'}")
 })
 
+test('buildVariableSyntax - default ${} syntax excludes IAM aws variables', () => {
+  const syntax = buildVariableSyntax('${', '}')
+  const regex = new RegExp(syntax, 'g')
+
+  assert.not.ok('${aws:username}'.match(regex))
+  assert.not.ok('arn:aws:s3:::bucket/${aws:PrincipalTag/team}/*'.match(regex))
+  assert.ok('${self:custom.value}'.match(regex))
+})
+
 test('buildVariableSyntax - double brace ${{}} syntax excludes }', () => {
   const syntax = buildVariableSyntax('${{', '}}')
   const regex = new RegExp(syntax, 'g')

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

@@ -4,15 +4,10 @@ declare class Configorama {
     settings: any;
     filterCache: {};
     _originalValueCache: Map<any, any>;
-    _resolvedPaths: Set<any>;
-    _fileContentCache: Map<any, any>;
-    _needsRawClone: boolean;
     foundVariables: any[];
     fileRefsFound: any[];
     resolutionTracking: {};
-    _trackCalls: boolean;
     variableSyntax: RegExp;
-    variableSyntaxTest: RegExp;
     varPrefix: string;
     varSuffix: string;
     varPrefixPattern: RegExp;
@@ -69,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":";AAyIA;IACE,0CAufC;IA/eC,cAkBW;IAuBX,gBAAqB;IAErB,mCAAoC;IAGpC,yBAA+B;IAG/B,iCAAkC;IAMlC,wBAIC;IAED,sBAAwB;IACxB,qBAAuB;IAGvB,uBAA4B;IAE5B,qBAAmD;IAsBnD,uBAAoC;IAIpC,2BAAkG;IAIlG,kBAAqC;IACrC,kBAAqC;IAErC,yBAA+F;IAC/F,yBAAuD;IACvD,kCAAyE;IAMrE,uBAAgD;IAMlD,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,CA+UxB;IA5UC,aAA4B;IAc1B,2BAA4B;IAqB1B,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,CAsG9B;IACD;;;OAGG;IACH;;;;;OAKG;IACH,oCAHa,OAAO,CAAC;;;;cA1HP,QAAQ;;;;eACR,IAAI,GAAC,MAAM,SAAO;OAyHgB,CAAC,EAAE,CAsClD;IACD;;;;;OAKG;IACH,iDAFa,OAAO,CAAC,IAAI,CAAC,CAoBzB;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,yDAkBC;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/valueFromFile.d.ts

@@ -14,7 +14,6 @@
  * @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>}
@@ -33,7 +32,6 @@ export function getValueFromFile(ctx: {
     textRefSyntax: RegExp;
     varPrefix: string;
     varSuffix: string;
-    fileContentCache?: Map<string, string>;
 }, variableString: string, options: object): Promise<any>;
 /**
  * Parse file contents based on file extension

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

@@ -1 +1 @@
-{"version":3,"file":"valueFromFile.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromFile.js"],"names":[],"mappings":"AA8FA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,sCAlBG;IAAoB,UAAU,EAAtB,MAAM;IACK,aAAa;IACZ,cAAc,EAA1B,MAAM;IACM,mBAAmB,EAA/B,MAAM;IACM,aAAa,EAAzB,MAAM;IACM,IAAI,EAAhB,MAAM;IACM,cAAc,EAA1B,MAAM;IACM,MAAM,EAAlB,MAAM;IACQ,cAAc;IAChB,aAAa,EAAzB,MAAM;IACM,aAAa,EAAzB,MAAM;IACM,SAAS,EAArB,MAAM;IACM,SAAS,EAArB,MAAM;IACoB,gBAAgB,GAA1C,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;CAC3B,kBAAQ,MAAM,WACN,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,CA+VxB;AA5YD;;;;;GAKG;AACH,2CAJW,MAAM,YACN,MAAM,GACJ,GAAC,CAoBb;AAsXD;;;;;;GAMG;AACH,qDAJW,MAAM,qBACN,MAAM,GACJ;IAAE,aAAa,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,GAAC,IAAI,CAAA;CAAE,CAkBhE;AAED;;;;;;GAMG;AACH,sDALW,MAAM,qBACN,MAAM,yBACN,OAAO,GACL,MAAM,EAAE,CAcpB"}
+{"version":3,"file":"valueFromFile.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromFile.js"],"names":[],"mappings":"AA8FA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,sCAjBG;IAAoB,UAAU,EAAtB,MAAM;IACK,aAAa;IACZ,cAAc,EAA1B,MAAM;IACM,mBAAmB,EAA/B,MAAM;IACM,aAAa,EAAzB,MAAM;IACM,IAAI,EAAhB,MAAM;IACM,cAAc,EAA1B,MAAM;IACM,MAAM,EAAlB,MAAM;IACQ,cAAc;IAChB,aAAa,EAAzB,MAAM;IACM,aAAa,EAAzB,MAAM;IACM,SAAS,EAArB,MAAM;IACM,SAAS,EAArB,MAAM;CACd,kBAAQ,MAAM,WACN,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,CAwVxB;AApYD;;;;;GAKG;AACH,2CAJW,MAAM,YACN,MAAM,GACJ,GAAC,CAoBb;AA8WD;;;;;;GAMG;AACH,qDAJW,MAAM,qBACN,MAAM,GACJ;IAAE,aAAa,EAAE,MAAM,EAAE,CAAC;IAAC,UAAU,EAAE,MAAM,GAAC,IAAI,CAAA;CAAE,CAkBhE;AAED;;;;;;GAMG;AACH,sDALW,MAAM,qBACN,MAAM,yBACN,OAAO,GACL,MAAM,EAAE,CAcpB"}

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/parsing/preProcess.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"preProcess.d.ts","sourceRoot":"","sources":["../../../../src/utils/parsing/preProcess.js"],"names":[],"mappings":";AASA;;;;;;;;GAQG;AACH,+DANW,MAAM,mCAGd;IAA0B,eAAe,GAAjC,OAAO;CACf,OA4XF"}
+{"version":3,"file":"preProcess.d.ts","sourceRoot":"","sources":["../../../../src/utils/parsing/preProcess.js"],"names":[],"mappings":";AASA;;;;;;;;GAQG;AACH,+DANW,MAAM,mCAGd;IAA0B,eAAe,GAAjC,OAAO;CACf,OAgYF"}

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"metadata.d.ts","sourceRoot":"","sources":["../../src/metadata.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;GAaG;AACH,mMAXG;IAAuB,cAAc,EAA7B,MAAM;IACS,mBAAmB;IACnB,aAAa;IACR,WAAW,EAA/B,MAAM,GAAC,IAAI;IACI,cAAc,EAA7B,MAAM;IACS,aAAa;IACb,cAAc;IACd,SAAS,EAAxB,MAAM;IACS,yBAAyB,EAAxC,MAAM;CACd,OAyaF"}

package/types/src/utils/BoundedMap.d.ts

@@ -1,10 +0,0 @@
-export = BoundedMap;
-declare class BoundedMap {
-    constructor(maxSize?: number);
-    _map: Map<any, any>;
-    _maxSize: number;
-    get(key: any): any;
-    has(key: any): boolean;
-    set(key: any, value: any): this;
-}
-//# sourceMappingURL=BoundedMap.d.ts.map

package/types/src/utils/BoundedMap.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"BoundedMap.d.ts","sourceRoot":"","sources":["../../../src/utils/BoundedMap.js"],"names":[],"mappings":";AAGA;IACE,8BAGC;IAFC,oBAAqB;IACrB,iBAAuB;IAEzB,mBAEC;IACD,uBAEC;IACD,gCAOC;CACF"}