configorama 0.7.1 → 0.8.0

package/src/resolvers/valueFromFile.js

@@ -197,7 +197,13 @@ async function getValueFromFile(ctx, variableString, options) {
     // console.log('NO FILE FOUND', fullFilePath)
     // console.log('variableString', variableString)
 
-    if (!hasFallback && !ctx.opts.allowUnknownFileRefs) {
+    // Check if file refs are allowed to pass through unresolved
+    const allowUnresolved = ctx.opts.allowUnresolvedVariables
+    const isFileAllowed = allowUnresolved === true ||
+      (Array.isArray(allowUnresolved) && allowUnresolved.includes('file')) ||
+      ctx.opts.allowUnknownFileRefs // backward compat
+
+    if (!hasFallback && !isFileAllowed) {
       const errorMsg = makeBox({
         title: `File Not Found in ${originalVar}`,
         minWidth: '100%',

package/src/resolvers/valueFromParam.js

@@ -0,0 +1,91 @@
+
+const paramRefSyntax = RegExp(/^param:/g)
+
+/**
+ * Resolves parameter values following the Serverless Framework parameter resolution hierarchy:
+ * 1. CLI params (--param="key=value")
+ * 2. Stage-specific params (stages.<stage>.params)
+ * 3. Default params (stages.default.params)
+ *
+ * @param {string} variableString - The variable string (e.g., "param:domain")
+ * @param {Object} options - CLI options that may contain params
+ * @param {Object} config - The full config object for stage-specific params
+ * @returns {Promise<any>} The resolved parameter value
+ */
+function getValueFromParam(variableString, options = {}, config = {}) {
+  const requestedParam = variableString.split(':')[1]
+
+  if (requestedParam === '') {
+    throw new Error(`Invalid variable syntax for parameter reference "${variableString}".
+
+\${param} variable must have a key path.
+
+Example: \${param:domain}
+`)
+  }
+
+  let valueToPopulate
+
+  // 1. First, check CLI params (--param="key=value")
+  // The param option can be either a string or an array of strings
+  if (options.param) {
+    const params = Array.isArray(options.param) ? options.param : [options.param]
+
+    // Parse param flags in the format "key=value"
+    for (const param of params) {
+      const [key, ...valueParts] = param.split('=')
+      if (key === requestedParam) {
+        valueToPopulate = valueParts.join('=') // rejoin in case value contains =
+        return Promise.resolve(valueToPopulate)
+      }
+    }
+  }
+
+  // 2. Check for stage-specific params (stages.<stage>.params)
+  const stage = options.stage || 'dev'
+  if (config.stages && config.stages[stage] && config.stages[stage].params) {
+    valueToPopulate = config.stages[stage].params[requestedParam]
+    if (valueToPopulate !== undefined) {
+      return Promise.resolve(valueToPopulate)
+    }
+  }
+
+  // 3. Check for default params (stages.default.params)
+  if (config.stages && config.stages.default && config.stages.default.params) {
+    valueToPopulate = config.stages.default.params[requestedParam]
+    if (valueToPopulate !== undefined) {
+      return Promise.resolve(valueToPopulate)
+    }
+  }
+
+  // 4. Check top-level params property (for backwards compatibility)
+  if (config.params) {
+    // Check stage-specific params first
+    if (config.params[stage]) {
+      valueToPopulate = config.params[stage][requestedParam]
+      if (valueToPopulate !== undefined) {
+        return Promise.resolve(valueToPopulate)
+      }
+    }
+
+    // Then check default params
+    if (config.params.default) {
+      valueToPopulate = config.params.default[requestedParam]
+      if (valueToPopulate !== undefined) {
+        return Promise.resolve(valueToPopulate)
+      }
+    }
+  }
+
+  // If not found, return undefined (will trigger fallback if specified)
+  return Promise.resolve(valueToPopulate)
+}
+
+module.exports = {
+  type: 'param',
+  source: 'user',
+  syntax: '${param:paramName}',
+  description: 'Resolves parameter values from CLI flags, stage-specific params, or default params. Examples: ${param:domain}, ${param:key, "fallbackValue"}',
+  match: paramRefSyntax,
+  resolver: getValueFromParam
+}

package/src/resolvers/valueFromParam.test.js

@@ -0,0 +1,207 @@
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { resolver } = require('./valueFromParam')
+
+test('Resolves parameter from CLI flag', async () => {
+  const options = { param: 'domain=myapp.com' }
+  const result = await resolver('param:domain', options)
+  assert.is(result, 'myapp.com')
+})
+
+test('Resolves parameter from multiple CLI flags', async () => {
+  const options = { param: ['domain=myapp.com', 'key=value'] }
+  const result = await resolver('param:key', options)
+  assert.is(result, 'value')
+})
+
+test('Resolves parameter with equals sign in value', async () => {
+  const options = { param: 'connectionString=Server=localhost;Port=5432' }
+  const result = await resolver('param:connectionString', options)
+  assert.is(result, 'Server=localhost;Port=5432')
+})
+
+test('Resolves parameter from stage-specific params', async () => {
+  const options = { stage: 'prod' }
+  const config = {
+    stages: {
+      prod: {
+        params: {
+          domain: 'production.myapp.com'
+        }
+      }
+    }
+  }
+  const result = await resolver('param:domain', options, config)
+  assert.is(result, 'production.myapp.com')
+})
+
+test('Resolves parameter from default stage params', async () => {
+  const options = { stage: 'dev' }
+  const config = {
+    stages: {
+      default: {
+        params: {
+          domain: 'default.myapp.com'
+        }
+      }
+    }
+  }
+  const result = await resolver('param:domain', options, config)
+  assert.is(result, 'default.myapp.com')
+})
+
+test('CLI params override stage params', async () => {
+  const options = {
+    stage: 'prod',
+    param: 'domain=cli-override.com'
+  }
+  const config = {
+    stages: {
+      prod: {
+        params: {
+          domain: 'production.myapp.com'
+        }
+      }
+    }
+  }
+  const result = await resolver('param:domain', options, config)
+  assert.is(result, 'cli-override.com')
+})
+
+test('Stage-specific params override default params', async () => {
+  const options = { stage: 'prod' }
+  const config = {
+    stages: {
+      default: {
+        params: {
+          domain: 'default.myapp.com'
+        }
+      },
+      prod: {
+        params: {
+          domain: 'production.myapp.com'
+        }
+      }
+    }
+  }
+  const result = await resolver('param:domain', options, config)
+  assert.is(result, 'production.myapp.com')
+})
+
+test('Returns undefined for non-existent parameter', async () => {
+  const options = { stage: 'dev' }
+  const config = { stages: { dev: { params: {} } } }
+  const result = await resolver('param:nonExistent', options, config)
+  assert.is(result, undefined)
+})
+
+test('Throws error for empty parameter name', async () => {
+  try {
+    await resolver('param:')
+    assert.unreachable('Should have thrown an error')
+  } catch (error) {
+    assert.ok(error.message.includes('Invalid variable syntax'))
+    assert.ok(error.message.includes('must have a key path'))
+  }
+})
+
+test('Defaults to dev stage when no stage specified', async () => {
+  const options = {}
+  const config = {
+    stages: {
+      dev: {
+        params: {
+          domain: 'dev.myapp.com'
+        }
+      }
+    }
+  }
+  const result = await resolver('param:domain', options, config)
+  assert.is(result, 'dev.myapp.com')
+})
+
+test('Supports top-level params property (backwards compatibility)', async () => {
+  const options = { stage: 'prod' }
+  const config = {
+    params: {
+      prod: {
+        domain: 'production.myapp.com'
+      }
+    }
+  }
+  const result = await resolver('param:domain', options, config)
+  assert.is(result, 'production.myapp.com')
+})
+
+test('Supports top-level params default property', async () => {
+  const options = { stage: 'dev' }
+  const config = {
+    params: {
+      default: {
+        domain: 'default.myapp.com'
+      }
+    }
+  }
+  const result = await resolver('param:domain', options, config)
+  assert.is(result, 'default.myapp.com')
+})
+
+test('Prefers stages property over params property', async () => {
+  const options = { stage: 'prod' }
+  const config = {
+    stages: {
+      prod: {
+        params: {
+          domain: 'stages.prod.myapp.com'
+        }
+      }
+    },
+    params: {
+      prod: {
+        domain: 'params.prod.myapp.com'
+      }
+    }
+  }
+  const result = await resolver('param:domain', options, config)
+  assert.is(result, 'stages.prod.myapp.com')
+})
+
+test('Returns Promise that resolves to value', async () => {
+  const options = { param: 'test=promise-value' }
+  const promise = resolver('param:test', options)
+  assert.ok(promise instanceof Promise)
+  const result = await promise
+  assert.is(result, 'promise-value')
+})
+
+test('Handles parameter with special characters in value', async () => {
+  const options = { param: 'special=value-with-special-chars-!@#$%' }
+  const result = await resolver('param:special', options)
+  assert.is(result, 'value-with-special-chars-!@#$%')
+})
+
+test('Handles empty string parameter value', async () => {
+  const options = { param: 'empty=' }
+  const result = await resolver('param:empty', options)
+  assert.is(result, '')
+})
+
+test('Handles numeric parameter value', async () => {
+  const options = { param: 'port=3000' }
+  const result = await resolver('param:port', options)
+  assert.is(result, '3000')
+})
+
+test('Handles parameter with underscore', async () => {
+  const options = { param: 'my_param=underscore-value' }
+  const result = await resolver('param:my_param', options)
+  assert.is(result, 'underscore-value')
+})
+
+test('Handles parameter with numbers', async () => {
+  const options = { param: 'param123=numeric-value' }
+  const result = await resolver('param:param123', options)
+  assert.is(result, 'numeric-value')
+})
+
+test.run()

package/src/utils/paths/filePathUtils.js

@@ -34,20 +34,44 @@ function normalizePath(filePath) {
 }
 
 /**
- * Extract file path from a file() or text() variable string
+ * Extract file path from a file() or text() variable string using balanced paren matching
  * @param {string} variableString - The variable string (with or without ${} wrapper)
  * @returns {object|null} Object with filePath, or null if no match
  */
 function extractFilePath(variableString) {
-  // Match both ${file(...)} and file(...) formats
-  const fileMatch = variableString.match(/^(?:\$\{)?(?:file|text)\((.*?)\)/)
-  if (!fileMatch || !fileMatch[1]) {
+  // Match the file( or text( prefix
+  const prefixMatch = variableString.match(/^(?:\$\{)?(file|text)\(/)
+  if (!prefixMatch) {
+    return null
+  }
+
+  // Find matching closing paren using depth tracking
+  const startIndex = prefixMatch[0].length - 1 // Position of opening (
+  let depth = 1
+  let i = startIndex + 1
+
+  while (i < variableString.length && depth > 0) {
+    if (variableString[i] === '(') {
+      depth++
+    } else if (variableString[i] === ')') {
+      depth--
+    }
+    i++
+  }
+
+  if (depth !== 0) {
+    return null
+  }
+
+  // Extract content between balanced parens
+  const fileContent = variableString.substring(startIndex + 1, i - 1).trim()
+  if (!fileContent) {
     return null
   }
 
   const { trimSurroundingQuotes } = require('../strings/quoteUtils')
-  const fileContent = fileMatch[1].trim()
-  const parts = splitCsv(fileContent)
+  // Protect ${} variables from being split (e.g., file paths with default values)
+  const parts = splitCsv(fileContent, undefined, { protectVariables: true })
   let filePath = parts[0].trim()
 
   // Remove quotes if present

package/src/utils/paths/filePathUtils.test.js

@@ -103,6 +103,22 @@ test('extractFilePath - handles bare filename', () => {
   assert.is(result.filePath, 'config.json')
 })
 
+test('extractFilePath - handles nested variable with default value in path', () => {
+  // This is the bug case: ${self:provider.stage, 'dev'} has a comma inside
+  const result = extractFilePath("file(./env.${self:provider.stage, 'dev'}.yml):FOO")
+  assert.is(result.filePath, "./env.${self:provider.stage, 'dev'}.yml")
+})
+
+test('extractFilePath - handles nested variable without default in path', () => {
+  const result = extractFilePath("file(./env.${self:provider.stage}.yml):FOO")
+  assert.is(result.filePath, "./env.${self:provider.stage}.yml")
+})
+
+test('extractFilePath - handles multiple nested variables in path', () => {
+  const result = extractFilePath("file(./config-${self:stage, 'dev'}-${self:region}.yml)")
+  assert.is(result.filePath, "./config-${self:stage, 'dev'}-${self:region}.yml")
+})
+
 // normalizeFileVariable tests
 
 test('normalizeFileVariable - returns non-file strings unchanged', () => {

package/src/utils/strings/splitCsv.js

@@ -1,14 +1,19 @@
 const { splitByComma } = require('./splitByComma')
 
+// Regex to match ${...} variables (used for protection during file path splitting)
+const VARIABLE_SYNTAX = /\${[^}]+}/g
+
 /**
  * Split a string by comma while preserving quoted content
  * 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 {object} [options] - Options object
+ * @param {boolean} [options.protectVariables] - If true, protect ${} variables from splitting
  * @returns {string[]} Array of split strings
  */
-function splitCsv(str, splitter) {
+function splitCsv(str, splitter, options = {}) {
   // If custom splitter is provided, fall back to original simple implementation
   if (splitter && splitter !== ',') {
     const splitSyntax = splitter
@@ -32,6 +37,10 @@ function splitCsv(str, splitter) {
   }
 
   // For standard comma splitting, use the more robust splitByComma
+  // Pass VARIABLE_SYNTAX if protectVariables is true to protect ${} from splitting
+  if (options.protectVariables) {
+    return splitByComma(str, VARIABLE_SYNTAX)
+  }
   return splitByComma(str)
 }
 

package/src/utils/variables/variableUtils.js

@@ -88,8 +88,61 @@ Remove or update the \${${variableString}} to fix
   return isRealVariable
 }
 
+/**
+ * Build default variable syntax regex with dynamic character class
+ * 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
+ * @returns {string} Regex source string
+ */
+function buildVariableSyntax(prefix = '${', suffix = '}', excludePatterns = ['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
+  // NOTE: $ is intentionally excluded - it's part of variable prefix and breaks nesting
+  const allChars = [
+    ' ', '~', ':', 'a-z', 'A-Z', '0-9', '=', '+', '!', '@', '#', '%',
+    '\\^', '&', ';', '`', '\\*', '<', '>', '\\?', '\\.', '_', "'", '"', ',',
+    '\\|', '\\-', '\\/', '\\(', '\\)', '\\[', '\\]', '\\\\'
+  ]
+
+  // Map of unescaped char to its escaped form in regex character class
+  const charEscapeMap = {
+    '^': '\\^', '*': '\\*', '?': '\\?', '.': '\\.', '|': '\\|',
+    '-': '\\-', '/': '\\/', '(': '\\(', ')': '\\)', '[': '\\[', ']': '\\]',
+    '\\': '\\\\'
+  }
+
+  // Get unique characters from suffix that need to be excluded
+  const suffixChars = [...new Set(suffix.split(''))]
+
+  // Filter out chars that appear in suffix
+  const allowedChars = allChars.filter(charEntry => {
+    for (const sc of suffixChars) {
+      const escaped = charEscapeMap[sc] || sc
+      if (charEntry === escaped || charEntry === sc) {
+        return false
+      }
+    }
+    return true
+  })
+
+  // Escape prefix and suffix for regex
+  const escapedPrefix = prefix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  const escapedSuffix = suffix.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+
+  // Build negative lookahead for excluded patterns
+  const lookahead = excludePatterns.length > 0
+    ? `(?!${excludePatterns.join('|')})`
+    : ''
+
+  return `${escapedPrefix}(${lookahead}[${allowedChars.join('')}]+?)${escapedSuffix}`
+}
+
 module.exports = {
   extractVariableWrapper,
   getFallbackString,
-  verifyVariable
+  verifyVariable,
+  buildVariableSyntax
 } 

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

@@ -150,5 +150,49 @@ test('extractVariableWrapper - strips non-capturing group prefix', () => {
   assert.equal(result.suffix, '}')
 })
 
+// Tests for buildVariableSyntax
+const { buildVariableSyntax } = require('./variableUtils')
+
+test('buildVariableSyntax - default ${} syntax excludes $ {', () => {
+  const syntax = buildVariableSyntax('${', '}')
+  const regex = new RegExp(syntax, 'g')
+  // $ and { in value cause no match (they're not in character class)
+  assert.not.ok("${env:FOO, 'test$value'}".match(regex))
+  assert.not.ok("${env:FOO, 'test{value'}".match(regex))
+  // } causes partial match (ends early at the } in value)
+  const partialMatch = "${env:FOO, 'test}value'}".match(regex)
+  assert.ok(partialMatch)
+  assert.is(partialMatch[0], "${env:FOO, 'test}")
+})
+
+test('buildVariableSyntax - supports backslash in values', () => {
+  const syntax = buildVariableSyntax('${', '}')
+  const regex = new RegExp(syntax, 'g')
+  const match = "${env:FOO, 'path\\to\\file'}".match(regex)
+  assert.is(match[0], "${env:FOO, 'path\\to\\file'}")
+})
+
+test('buildVariableSyntax - double brace ${{}} syntax excludes }', () => {
+  const syntax = buildVariableSyntax('${{', '}}')
+  const regex = new RegExp(syntax, 'g')
+  const match = "${{env:FOO, 'value'}}".match(regex)
+  assert.is(match[0], "${{env:FOO, 'value'}}")
+})
+
+test('buildVariableSyntax - angle bracket <> syntax excludes >', () => {
+  const syntax = buildVariableSyntax('<', '>')
+  const regex = new RegExp(syntax, 'g')
+  // > in value causes partial match
+  const match = "<env:FOO, 'a>b'>".match(regex)
+  assert.is(match[0], "<env:FOO, 'a>")
+})
+
+test('buildVariableSyntax - bracket [[]] syntax excludes ]', () => {
+  const syntax = buildVariableSyntax('[[', ']]')
+  const regex = new RegExp(syntax, 'g')
+  const match = "[[env:FOO, 'value']]".match(regex)
+  assert.is(match[0], "[[env:FOO, 'value']]")
+})
+
 // Run all tests
 test.run()

package/types/src/index.d.ts

@@ -3,10 +3,11 @@ declare namespace _exports {
 }
 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 { Configorama };
+    export { buildVariableSyntax };
 }
 export = _exports;
 type ConfigoramaSettings = {
@@ -95,6 +96,7 @@ type ConfigoramaResult<T = any> = {
      */
     resolutionHistory: any;
 };
-import Configorama = require("./main");
 import parsers = require("./parsers");
+import Configorama = require("./main");
+import { buildVariableSyntax } from "./utils/variables/variableUtils";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +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"}
+{"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

@@ -27,6 +27,24 @@ declare class Configorama {
     deep: any[];
     leaves: any[];
     callCount: number;
+    /**
+     * Check if unresolved variables of a given type should pass through
+     * @param {string} type - The resolver type (e.g., 'param', 'file', 'env')
+     * @returns {boolean}
+     */
+    isUnresolvedAllowed(type: string): boolean;
+    /**
+     * Extract type prefix from a variable string
+     * @param {string} varString - Variable string like 'ssm:path/to/thing' or 'custom:value'
+     * @returns {string|null} The type prefix or null if not found
+     */
+    extractTypePrefix(varString: string): string | null;
+    /**
+     * Check if unknown variable types should pass through
+     * @param {string} varString - Variable string like 'ssm:path' or full '${ssm:path}'
+     * @returns {boolean}
+     */
+    isUnknownTypeAllowed(varString: string): boolean;
     /**
      * Populate all variables in the service, conveniently remove and restore the service attributes
      * that confuse the population methods.

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

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/main.js"],"names":[],"mappings":";AA6HA;IACE,0CAgaC;IAxZC,cAaW;IAOX,gBAAqB;IAErB,sBAAwB;IACxB,qBAAuB;IAGvB,uBAA4B;IAc5B,uBAAoC;IAIpC,kBAAqC;IACrC,kBAAqC;IAErC,yBAA+F;IAC/F,yBAAuD;IACvD,kCAAyE;IAKvE,YAA0B;IAE1B,oBAA6C;IAE7C,gBAAoD;IAOpD,uBAAkC;IAElC,uBAA8B;IAE9B,uBAAkC;IASpC,wBAAmC;IAGnC,mBAsGC;IAoED,4BAA8C;IAO9C,aA2EC;IAUD,oBAEC;IAGD,eAkDC;IAOD,YAAc;IACd,cAAgB;IAChB,kBAAkB;IAMpB;;;;;OAKG;IACH,oBAFa,OAAO,CAAC,GAAG,CAAC,CAqsBxB;IAlsBC,aAA4B;IAc1B,2BAA4B;IAQ5B,uBAAgD;IA8qBpD;;;OAGG;IACH,2BAFa,MAAM,CA8alB;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,CA+D9B;IACD;;;OAGG;IACH;;;;;OAKG;IACH,oCAHa,OAAO,CAAC;;;;cAnFP,QAAQ;;;;eACR,IAAI,GAAC,MAAM,SAAO;OAkFgB,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,CA+Kb;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,CAmY9J;IAID;;;;;;;;OAQG;IACH,qEAHa,OAAO,CAAC,GAAG,CAAC,CAoExB;IAKD;;;;;;;OAOG;IACH,0FAFa,OAAO,CAAC,GAAG,CAAC,CAofxB;IACD,+EA8BC;IACD,yDAeC;IACD,oEA6BC;IAKD,8CAQC;IACD,kDAyBC;IACD;;;;;;;;;;;;;OAaG;IACH,wEAoDC;IAKD,4BAOC;IACD,sCAoDC;CACF"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/main.js"],"names":[],"mappings":";AA0GA;IACE,0CAwbC;IAhbC,cAaW;IAuBX,gBAAqB;IAErB,sBAAwB;IACxB,qBAAuB;IAGvB,uBAA4B;IAc5B,uBAAoC;IAIpC,kBAAqC;IACrC,kBAAqC;IAErC,yBAA+F;IAC/F,yBAAuD;IACvD,kCAAyE;IAKvE,YAA0B;IAE1B,oBAA6C;IAE7C,gBAAoD;IAOpD,uBAAkC;IAElC,uBAA8B;IAE9B,uBAAkC;IASpC,wBAAmC;IAGnC,mBA8GC;IAoED,4BAA8C;IAO9C,aA2EC;IAUD,oBAEC;IAGD,eAkDC;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,CAoBnB;IAKD;;;;;OAKG;IACH,oBAFa,OAAO,CAAC,GAAG,CAAC,CAqsBxB;IAlsBC,aAA4B;IAc1B,2BAA4B;IAQ5B,uBAAgD;IA8qBpD;;;OAGG;IACH,2BAFa,MAAM,CA8alB;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,CA+D9B;IACD;;;OAGG;IACH;;;;;OAKG;IACH,oCAHa,OAAO,CAAC;;;;cAnFP,QAAQ;;;;eACR,IAAI,GAAC,MAAM,SAAO;OAkFgB,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,CA+Kb;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,CAmY9J;IAID;;;;;;;;OAQG;IACH,qEAHa,OAAO,CAAC,GAAG,CAAC,CAoExB;IAKD;;;;;;;OAOG;IACH,0FAFa,OAAO,CAAC,GAAG,CAAC,CA0fxB;IACD,+EA8BC;IACD,yDAeC;IACD,oEA6BC;IAKD,8CAQC;IACD,kDAyBC;IACD;;;;;;;;;;;;;OAaG;IACH,wEAoDC;IAKD,4BAOC;IACD,sCAoDC;CACF"}

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

@@ -1 +1 @@
-{"version":3,"file":"valueFromFile.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromFile.js"],"names":[],"mappings":"AAkEA;;;;;;;;;;;;;;;;;GAiBG;AACH,sCAfG;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;CACd,kBAAQ,MAAM,WACN,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,CA8SxB;AAxVD;;;;;GAKG;AACH,2CAJW,MAAM,YACN,MAAM,GACJ,GAAC,CAoBb;AAkUD;;;;;;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":"AAkEA;;;;;;;;;;;;;;;;;GAiBG;AACH,sCAfG;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;CACd,kBAAQ,MAAM,WACN,MAAM,GACJ,OAAO,CAAC,GAAG,CAAC,CAoTxB;AA9VD;;;;;GAKG;AACH,2CAJW,MAAM,YACN,MAAM,GACJ,GAAC,CAoBb;AAwUD;;;;;;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/valueFromParam.d.ts

@@ -0,0 +1,19 @@
+declare const paramRefSyntax: RegExp;
+/**
+ * Resolves parameter values following the Serverless Framework parameter resolution hierarchy:
+ * 1. CLI params (--param="key=value")
+ * 2. Stage-specific params (stages.<stage>.params)
+ * 3. Default params (stages.default.params)
+ *
+ * @param {string} variableString - The variable string (e.g., "param:domain")
+ * @param {Object} options - CLI options that may contain params
+ * @param {Object} config - The full config object for stage-specific params
+ * @returns {Promise<any>} The resolved parameter value
+ */
+declare function getValueFromParam(variableString: string, options?: any, config?: any): Promise<any>;
+export declare let type: string;
+export declare let source: string;
+export declare let syntax: string;
+export declare let description: string;
+export { paramRefSyntax as match, getValueFromParam as resolver };
+//# sourceMappingURL=valueFromParam.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"valueFromParam.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromParam.js"],"names":[],"mappings":"AACA,qCAAyC;AAEzC;;;;;;;;;;GAUG;AACH,mDALW,MAAM,gCAGJ,OAAO,CAAC,GAAG,CAAC,CAqExB"}

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

@@ -5,7 +5,7 @@
  */
 export function normalizePath(filePath: string): string | null;
 /**
- * Extract file path from a file() or text() variable string
+ * Extract file path from a file() or text() variable string using balanced paren matching
  * @param {string} variableString - The variable string (with or without ${} wrapper)
  * @returns {object|null} Object with filePath, or null if no match
  */

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

@@ -1 +1 @@
-{"version":3,"file":"filePathUtils.d.ts","sourceRoot":"","sources":["../../../../src/utils/paths/filePathUtils.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,wCAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CA0BvB;AAED;;;;GAIG;AACH,gDAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAkBvB;AAED;;;;;GAKG;AACH,sDAHW,MAAM,GACJ,MAAM,CAkBlB;AAED;;;;;;;GAOG;AACH,2CANW,MAAM,kBACN,MAAM,UACN,MAAM,sBAEJ;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAC,CAwCnD"}
+{"version":3,"file":"filePathUtils.d.ts","sourceRoot":"","sources":["../../../../src/utils/paths/filePathUtils.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,wCAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CA0BvB;AAED;;;;GAIG;AACH,gDAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CA0CvB;AAED;;;;;GAKG;AACH,sDAHW,MAAM,GACJ,MAAM,CAkBlB;AAED;;;;;;;GAOG;AACH,2CANW,MAAM,kBACN,MAAM,UACN,MAAM,sBAEJ;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,OAAO,CAAA;CAAC,CAwCnD"}

package/types/src/utils/strings/splitCsv.d.ts

@@ -4,7 +4,11 @@
  * 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 {object} [options] - Options object
+ * @param {boolean} [options.protectVariables] - If true, protect ${} variables from splitting
  * @returns {string[]} Array of split strings
  */
-export function splitCsv(str: string, splitter?: string): string[];
+export function splitCsv(str: string, splitter?: string, options?: {
+    protectVariables?: boolean;
+}): string[];
 //# sourceMappingURL=splitCsv.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"splitCsv.d.ts","sourceRoot":"","sources":["../../../../src/utils/strings/splitCsv.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,8BAJW,MAAM,aACN,MAAM,GACJ,MAAM,EAAE,CA2BpB"}
+{"version":3,"file":"splitCsv.d.ts","sourceRoot":"","sources":["../../../../src/utils/strings/splitCsv.js"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH,8BANW,MAAM,aACN,MAAM,YAEd;IAA0B,gBAAgB,GAAlC,OAAO;CACf,GAAU,MAAM,EAAE,CA+BpB"}