configorama 0.9.8 → 0.9.12

package/src/utils/regex/index.js

@@ -27,12 +27,27 @@ function parseFunctionCall(str) {
   
   let depth = 1
   let pos = startPos
-  
+  let inString = null // null, '"', or "'"
+
   // Track parenthesis depth to find matching closing paren
   while (pos < str.length && depth > 0) {
     const char = str[pos]
-    if (char === '(') depth++
-    else if (char === ')') depth--
+    const prevChar = pos > 0 ? str[pos - 1] : ''
+
+    // Toggle string state on unescaped quotes
+    if ((char === '"' || char === "'") && prevChar !== '\\') {
+      if (!inString) {
+        inString = char
+      } else if (char === inString) {
+        inString = null
+      }
+    }
+
+    // Only count parens outside strings
+    if (!inString) {
+      if (char === '(') depth++
+      else if (char === ')') depth--
+    }
     pos++
   }
   

package/src/utils/regex/index.test.js

@@ -91,6 +91,30 @@ test('parseFunctionCall - handles multiple parens in text', () => {
   assert.is(result[2], "'Choose option (A) or (B) or (C)'")
 })
 
+test('parseFunctionCall - handles unbalanced close paren in string', () => {
+  const result = parseFunctionCall('func("value)")')
+  assert.ok(result)
+  assert.is(result[0], 'func("value)")')
+  assert.is(result[1], 'func')
+  assert.is(result[2], '"value)"')
+})
+
+test('parseFunctionCall - handles unbalanced open paren in string', () => {
+  const result = parseFunctionCall("func('open (')")
+  assert.ok(result)
+  assert.is(result[0], "func('open (')")
+  assert.is(result[1], 'func')
+  assert.is(result[2], "'open ('")
+})
+
+test('parseFunctionCall - handles multiple unbalanced parens in string', () => {
+  const result = parseFunctionCall('func("))))")')
+  assert.ok(result)
+  assert.is(result[0], 'func("))))")')
+  assert.is(result[1], 'func')
+  assert.is(result[2], '"))))"')
+})
+
 // ==========================================
 // parseFunctionCall - edge cases
 // ==========================================

package/src/utils/strings/quoteAware.js

@@ -0,0 +1,141 @@
+/* Quote-aware string processing utilities */
+
+/**
+ * Find index of a character/pattern outside of quoted strings
+ * @param {string} str - String to search
+ * @param {string|function} matcher - Char to find, or function(str, idx) => matchLength|0
+ * @param {number} [startIdx=0] - Start index
+ * @returns {number} Index of match, or -1 if not found
+ */
+function findOutsideQuotes(str, matcher, startIdx = 0) {
+  let inQuote = false
+  let quoteChar = ''
+
+  for (let i = startIdx; i < str.length; i++) {
+    const ch = str[i]
+
+    if (!inQuote && (ch === '"' || ch === "'")) {
+      inQuote = true
+      quoteChar = ch
+    } else if (inQuote && ch === quoteChar) {
+      inQuote = false
+    } else if (!inQuote) {
+      if (typeof matcher === 'function') {
+        const matchLen = matcher(str, i)
+        if (matchLen > 0) return i
+      } else if (ch === matcher) {
+        return i
+      }
+    }
+  }
+
+  return -1
+}
+
+/**
+ * Replace a pattern only outside of quoted strings
+ * @param {string} str - String to process
+ * @param {string|RegExp} pattern - Pattern to match (if string, must be exact match)
+ * @param {string|function} replacement - Replacement string or function(match) => string
+ * @returns {string} Processed string
+ */
+function replaceOutsideQuotes(str, pattern, replacement) {
+  let result = ''
+  let inQuote = false
+  let quoteChar = ''
+  let i = 0
+
+  const patternStr = typeof pattern === 'string' ? pattern : null
+  const patternLen = patternStr ? patternStr.length : 0
+
+  while (i < str.length) {
+    const ch = str[i]
+
+    if (!inQuote && (ch === '"' || ch === "'")) {
+      inQuote = true
+      quoteChar = ch
+      result += ch
+      i++
+    } else if (inQuote && ch === quoteChar) {
+      inQuote = false
+      result += ch
+      i++
+    } else if (!inQuote && patternStr) {
+      // String pattern - check for exact match with word boundaries
+      if (str.substring(i, i + patternLen) === patternStr) {
+        const before = i === 0 || !/\w/.test(str[i - 1])
+        const after = i + patternLen >= str.length || !/\w/.test(str[i + patternLen])
+        if (before && after) {
+          const rep = typeof replacement === 'function' ? replacement(patternStr) : replacement
+          result += rep
+          i += patternLen
+          continue
+        }
+      }
+      result += ch
+      i++
+    } else {
+      result += ch
+      i++
+    }
+  }
+
+  return result
+}
+
+/**
+ * Check if an index is inside a quoted string
+ * @param {string} str - String to check
+ * @param {number} idx - Index to check
+ * @returns {boolean} True if index is inside quotes
+ */
+function isInsideQuotes(str, idx) {
+  let inQuote = false
+  let quoteChar = ''
+
+  for (let i = 0; i < str.length && i <= idx; i++) {
+    const ch = str[i]
+    if (!inQuote && (ch === '"' || ch === "'")) {
+      inQuote = true
+      quoteChar = ch
+    } else if (inQuote && ch === quoteChar) {
+      inQuote = false
+    }
+  }
+
+  return inQuote
+}
+
+/**
+ * Get ranges of quoted strings in a string
+ * @param {string} str - String to analyze
+ * @returns {Array<[number, number]>} Array of [start, end] ranges
+ */
+function getQuoteRanges(str) {
+  /** @type {Array<[number, number]>} */
+  const ranges = []
+  let inQuote = false
+  let quoteChar = ''
+  let quoteStart = 0
+
+  for (let i = 0; i < str.length; i++) {
+    const ch = str[i]
+    if (!inQuote && (ch === '"' || ch === "'")) {
+      inQuote = true
+      quoteChar = ch
+      quoteStart = i
+    } else if (inQuote && ch === quoteChar) {
+      ranges.push([quoteStart, i + 1])
+      inQuote = false
+    }
+  }
+
+  return ranges
+}
+
+module.exports = {
+  findOutsideQuotes,
+  replaceOutsideQuotes,
+  isInsideQuotes,
+  getQuoteRanges
+}

package/src/utils/strings/replaceAll.js

@@ -1,5 +1,8 @@
 const REPLACE_PATTERN = /([\/\,\!\\\^\$\{\}\[\]\(\)\.\*\+\?\|<>\-\&])/g
 
+// Cache for compiled regex patterns (perf: avoid recompilation)
+const regexCache = new Map()
+
 /**
  * Replace all occurrences of a string while handling regex special characters
  * @param {string} replaceThis - String to replace
@@ -9,7 +12,16 @@ const REPLACE_PATTERN = /([\/\,\!\\\^\$\{\}\[\]\(\)\.\*\+\?\|<>\-\&])/g
  */
 function replaceAll(replaceThis, withThis, inThis) {
   withThis = withThis.replace(/\$/g, '$$$$')
-  const pat = new RegExp(replaceThis.replace(REPLACE_PATTERN, '\\$&'), 'g')
+
+  // Check cache first
+  let pat = regexCache.get(replaceThis)
+  if (!pat) {
+    pat = new RegExp(replaceThis.replace(REPLACE_PATTERN, '\\$&'), 'g')
+    regexCache.set(replaceThis, pat)
+  }
+
+  // Reset lastIndex for global regex reuse
+  pat.lastIndex = 0
   return inThis.replace(pat, withThis)
 }
 

package/src/utils/strings/splitByComma.js

@@ -32,7 +32,7 @@ function splitByComma(string, regexPattern) {
   }
 
   const result = []
-  let current = ""
+  let segmentStart = 0  // Track segment start index (perf: avoid string concat)
   let inQuote = false
   let quoteChar = ""
   let bracketDepth = 0  // Includes (), [], and {}
@@ -43,12 +43,22 @@ function splitByComma(string, regexPattern) {
     const prevChar = i > 0 ? protectedString[i-1] : ''
 
     // Handle quotes
-    if ((char === "'" || char === '"') && (i === 0 || protectedString[i-1] !== "\\")) {
-      if (!inQuote) {
-        inQuote = true
-        quoteChar = char
-      } else if (char === quoteChar) {
-        inQuote = false
+    if (char === "'" || char === '"') {
+      // Count consecutive backslashes before this quote
+      let backslashCount = 0
+      for (let j = i - 1; j >= 0 && protectedString[j] === "\\"; j--) {
+        backslashCount++
+      }
+      // Quote is escaped only if preceded by odd number of backslashes
+      const isEscaped = backslashCount % 2 === 1
+
+      if (!isEscaped) {
+        if (!inQuote) {
+          inQuote = true
+          quoteChar = char
+        } else if (char === quoteChar) {
+          inQuote = false
+        }
       }
     }
 
@@ -78,17 +88,17 @@ function splitByComma(string, regexPattern) {
       }
     }
 
-    // Process comma
+    // Process comma - use substring instead of char-by-char concat
     if (char === "," && !inQuote && bracketDepth === 0 && dollarBraceDepth === 0) {
-      result.push(current.trim())
-      current = ""
-    } else {
-      current += char
+      result.push(protectedString.substring(segmentStart, i).trim())
+      segmentStart = i + 1
     }
   }
-  
-  if (current.trim() || result.length > 0) {
-    result.push(current.trim())
+
+  // Add final segment
+  const finalSegment = protectedString.substring(segmentStart).trim()
+  if (finalSegment || result.length > 0) {
+    result.push(finalSegment)
   }
 
   if (!regexPattern) {

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

@@ -125,5 +125,24 @@ test('splitByComma - should handle deeply nested variables with regex', () => {
   assert.equal(result[3], '"three"')
 })
 
+test('splitByComma - should handle escaped backslash before closing quote', () => {
+  // 'text\\' = literal backslash at end of string, quote should close it
+  const result = splitByComma("before, 'text\\\\', after")
+  assert.equal(result, ["before", "'text\\\\'", "after"])
+})
+
+test('splitByComma - should handle multiple escaped backslashes before quote', () => {
+  // 'test\\\\' = two literal backslashes at end, quote should close it
+  const result = splitByComma("a, 'test\\\\\\\\', b")
+  assert.equal(result, ["a", "'test\\\\\\\\'", "b"])
+})
+
+test('splitByComma - should handle odd backslashes (escaped quote)', () => {
+  // 'test\\\' = one literal backslash + escaped quote, string not closed
+  // This should NOT split since the quote is escaped
+  const result = splitByComma("a, 'test\\\\\\'quoted', b")
+  assert.equal(result, ["a", "'test\\\\\\'quoted'", "b"])
+})
+
 // Run all tests
 test.run() 

package/src/utils/strings/splitOnPipe.js

@@ -0,0 +1,30 @@
+/* Splits string on single pipe (|) but preserves double pipes (||) */
+
+const DOUBLE_PIPE_PLACEHOLDER = '\x00DOUBLE_PIPE\x00'
+// Pre-compile regex for placeholder restoration (perf: avoid recompilation in map)
+const DOUBLE_PIPE_REGEX = /\|\|/g
+const PLACEHOLDER_RESTORE_REGEX = new RegExp(DOUBLE_PIPE_PLACEHOLDER, 'g')
+
+/**
+ * Splits a string on single pipe (|) characters while preserving double pipes (||).
+ * This is needed for filter parsing since || is a logical operator, not a filter delimiter.
+ * @param {string} str - String to split
+ * @returns {string[]} - Array of parts split on single |
+ */
+function splitOnPipe(str) {
+  if (!str || typeof str !== 'string') return [str]
+
+  // Replace || with placeholder, split on |, restore ||
+  DOUBLE_PIPE_REGEX.lastIndex = 0
+  const parts = str.replace(DOUBLE_PIPE_REGEX, DOUBLE_PIPE_PLACEHOLDER).split('|')
+
+  // Only restore placeholders if we actually had any
+  if (str.indexOf('||') === -1) return parts
+
+  return parts.map(s => {
+    PLACEHOLDER_RESTORE_REGEX.lastIndex = 0
+    return s.replace(PLACEHOLDER_RESTORE_REGEX, '||')
+  })
+}
+
+module.exports = { splitOnPipe }

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

@@ -0,0 +1,68 @@
+/* Tests for splitOnPipe utility */
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { splitOnPipe } = require('./splitOnPipe')
+
+test('splitOnPipe - single pipe', () => {
+  const result = splitOnPipe('a | b')
+  assert.equal(result, ['a ', ' b'])
+})
+
+test('splitOnPipe - multiple single pipes', () => {
+  const result = splitOnPipe('a | b | c')
+  assert.equal(result, ['a ', ' b ', ' c'])
+})
+
+test('splitOnPipe - preserves double pipe', () => {
+  const result = splitOnPipe('a || b')
+  assert.equal(result, ['a || b'])
+})
+
+test('splitOnPipe - eval with logical OR', () => {
+  const result = splitOnPipe('eval(true || undefined)')
+  assert.equal(result, ['eval(true || undefined)'])
+})
+
+test('splitOnPipe - mixed single and double pipes', () => {
+  const result = splitOnPipe('eval(a || b) | filter')
+  assert.equal(result, ['eval(a || b) ', ' filter'])
+})
+
+test('splitOnPipe - multiple double pipes', () => {
+  const result = splitOnPipe('a || b || c')
+  assert.equal(result, ['a || b || c'])
+})
+
+test('splitOnPipe - double pipe followed by single pipe', () => {
+  const result = splitOnPipe('a || b | c')
+  assert.equal(result, ['a || b ', ' c'])
+})
+
+test('splitOnPipe - empty string', () => {
+  const result = splitOnPipe('')
+  assert.equal(result, [''])
+})
+
+test('splitOnPipe - no pipes', () => {
+  const result = splitOnPipe('abc')
+  assert.equal(result, ['abc'])
+})
+
+test('splitOnPipe - null input', () => {
+  const result = splitOnPipe(null)
+  assert.equal(result, [null])
+})
+
+test('splitOnPipe - undefined input', () => {
+  const result = splitOnPipe(undefined)
+  assert.equal(result, [undefined])
+})
+
+test('splitOnPipe - bitwise OR should be preserved', () => {
+  // Note: bitwise | is a single pipe, so it WILL be split
+  // This is expected - bitwise OR in eval still won't work with filters
+  const result = splitOnPipe('eval(5 | 3)')
+  assert.equal(result, ['eval(5 ', ' 3)'])
+})
+
+test.run()

package/src/utils/validation/isValidValue.test.js

@@ -24,7 +24,7 @@ test('isValidValue - should return true for non-empty array', () => {
   assert.is(isValidValue([1, 2, 3]), true)
 })
 
-test.skip('isValidValue - should return false for null', () => {
+test('isValidValue - should return false for null', () => {
   assert.is(isValidValue(null), false)
 })
 

package/src/utils/variables/findNestedVariables.js

@@ -53,7 +53,9 @@ function findNestedVariables(input, regex, variablesKnownTypes, location, variab
     
     // Generate a unique placeholder
     const placeholder = `__VAR_${iteration - 1}__`
-    
+    // Pre-compile regex for this placeholder (perf: avoids recompilation in replaceAllPlaceholders)
+    const placeholderRegex = new RegExp(placeholder, 'g')
+
     // Store match details
     const matchInfo = {
       variableType: undefined,
@@ -66,6 +68,7 @@ function findNestedVariables(input, regex, variablesKnownTypes, location, variab
       start: match.index,
       end: match.index + match[0].length,
       placeholder,
+      placeholderRegex,
     }
     
     if (debug) {
@@ -136,7 +139,9 @@ function findNestedVariables(input, regex, variablesKnownTypes, location, variab
     for (let i = 0; i < matchesArray.length; i++) {
       const m = matchesArray[i]
       if (result.includes(m.placeholder)) {
-        result = result.replace(new RegExp(m.placeholder, 'g'), m[key])
+        // Reset lastIndex before reusing global regex
+        m.placeholderRegex.lastIndex = 0
+        result = result.replace(m.placeholderRegex, m[key])
         needsAnotherPass = true
       }
     }
@@ -219,6 +224,7 @@ function findNestedVariables(input, regex, variablesKnownTypes, location, variab
 
   const finalMatches = matches.map((m) => {
     delete m.placeholder
+    delete m.placeholderRegex
     if (typeof m.variableType === 'undefined') {
       /*
       {

package/types/src/main.d.ts

@@ -3,6 +3,7 @@ declare class Configorama {
     constructor(fileOrObject: any, opts: any);
     settings: any;
     filterCache: {};
+    _originalValueCache: Map<any, any>;
     foundVariables: any[];
     fileRefsFound: any[];
     resolutionTracking: {};
@@ -12,6 +13,7 @@ declare class Configorama {
     varPrefixPattern: RegExp;
     varSuffixPattern: RegExp;
     varSuffixWithSpacePattern: RegExp;
+    rawOriginalConfig: any;
     config: any;
     originalConfig: any;
     configPath: any;
@@ -21,6 +23,7 @@ declare class Configorama {
     tracker: PromiseTracker;
     variableTypes: any;
     variablesKnownTypes: RegExp;
+    _resolverByPrefix: Map<any, any>;
     filters: any;
     filterMatch: RegExp;
     functions: any;
@@ -54,7 +57,6 @@ declare class Configorama {
     init(cliOpts: any): Promise<any>;
     options: any;
     configFileContents: string;
-    rawOriginalConfig: any;
     /**
      * Collect metadata about all variables found in the configuration
      * @returns {object} Metadata object containing variables, fileRefs, and summary

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

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/main.js"],"names":[],"mappings":";AA0GA;IACE,0CAqcC;IA7bC,cAcW;IAuBX,gBAAqB;IAErB,sBAAwB;IACxB,qBAAuB;IAGvB,uBAA4B;IAsB5B,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;IAwED,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,CA6gBxB;IACD,+EA+BC;IACD,yDAiBC;IACD,oEA6BC;IAKD,8CAQC;IACD,kDAyBC;IACD;;;;;;;;;;;;;OAaG;IACH,wEAoDC;IAKD,4BAOC;IACD,sCA2DC;CACF"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/main.js"],"names":[],"mappings":";AA6GA;IACE,0CA4dC;IApdC,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,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,CA2BnB;IAKD;;;;;OAKG;IACH,oBAFa,OAAO,CAAC,GAAG,CAAC,CAgvBxB;IA7uBC,aAA4B;IAc1B,2BAA4B;IAiuBhC;;;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,CAma9J;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/parsers/esm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"esm.d.ts","sourceRoot":"","sources":["../../../src/parsers/esm.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,yCAJW,MAAM,eAEJ,OAAO,CAAC,GAAC,CAAC,CA0BtB;AAED;;;;;GAKG;AACH,6CAJW,MAAM,eAEJ,GAAC,CAyBb"}
+{"version":3,"file":"esm.d.ts","sourceRoot":"","sources":["../../../src/parsers/esm.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,yCAJW,MAAM,eAEJ,OAAO,CAAC,GAAC,CAAC,CAmBtB;AAED;;;;;GAKG;AACH,6CAJW,MAAM,eAEJ,GAAC,CAkBb"}

package/types/src/parsers/typescript.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../../src/parsers/typescript.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,gDAJW,MAAM,eAEJ,OAAO,CAAC,GAAC,CAAC,CAwDtB;AAED;;;;;GAKG;AACH,oDAJW,MAAM,eAEJ,GAAC,CAwDb"}
+{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../../src/parsers/typescript.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,gDAJW,MAAM,eAEJ,OAAO,CAAC,GAAC,CAAC,CAmDtB;AAED;;;;;GAKG;AACH,oDAJW,MAAM,eAEJ,GAAC,CAmDb"}

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

@@ -1,3 +1,4 @@
+export function encodeValue(value: any): string;
 declare const evalRefSyntax: RegExp;
 declare function getValueFromEval(variableString: any): Promise<any>;
 export declare let type: string;

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

@@ -1 +1 @@
-{"version":3,"file":"valueFromEval.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromEval.js"],"names":[],"mappings":"AACA,oCAA+C;AAE/C,qEA2BC"}
+{"version":3,"file":"valueFromEval.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromEval.js"],"names":[],"mappings":"AAQA,gDAIC;AAXD,oCAA+C;AAyC/C,qEA6CC"}

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

@@ -0,0 +1,7 @@
+declare const ifRefSyntax: RegExp;
+declare function getValueFromIf(variableString: any): Promise<any>;
+export declare let type: string;
+export declare let source: string;
+export declare let description: string;
+export { ifRefSyntax as match, getValueFromIf as resolver };
+//# sourceMappingURL=valueFromIf.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"valueFromIf.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromIf.js"],"names":[],"mappings":"AAOA,kCAAqD;AAErD,mEAyDC"}

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

@@ -1 +1 @@
-{"version":3,"file":"valueFromNumber.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromNumber.js"],"names":[],"mappings":"AAEA,4DAGC;AAED,0EAEC"}
+{"version":3,"file":"valueFromNumber.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromNumber.js"],"names":[],"mappings":"AAEA,4DAMC;AAED,0EAEC"}

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

@@ -1 +1 @@
-{"version":3,"file":"handleSignalEvents.d.ts","sourceRoot":"","sources":["../../../src/utils/handleSignalEvents.js"],"names":[],"mappings":";AAEA,4CAsDC"}
+{"version":3,"file":"handleSignalEvents.d.ts","sourceRoot":"","sources":["../../../src/utils/handleSignalEvents.js"],"names":[],"mappings":";AAEA,4CAqDC"}

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

@@ -1 +1 @@
-{"version":3,"file":"lodash.d.ts","sourceRoot":"","sources":["../../../src/utils/lodash.js"],"names":[],"mappings":"AAkDA,mDAoBC;AApDD,6DA6BC"}
+{"version":3,"file":"lodash.d.ts","sourceRoot":"","sources":["../../../src/utils/lodash.js"],"names":[],"mappings":"AAqDA,mDA4BC;AA/DD,6DA6BC"}

package/types/src/utils/parsing/preProcess.d.ts

@@ -4,7 +4,11 @@ export = preProcess;
  * @param {Object} configObject - The parsed configuration object
  * @param {RegExp} variableSyntax - The variable syntax regex to use
  * @param {Array} [variableTypes] - Array of variable type definitions with type/prefix fields
+ * @param {Object} [options] - Options for preprocessing
+ * @param {boolean} [options.skipFallbackFix] - Skip fixing malformed fallbacks (for object configs)
  * @returns {Object} The preprocessed configuration object
  */
-declare function preProcess(configObject: any, variableSyntax: RegExp, variableTypes?: any[]): any;
+declare function preProcess(configObject: any, variableSyntax: RegExp, variableTypes?: any[], options?: {
+    skipFallbackFix?: boolean;
+}): any;
 //# sourceMappingURL=preProcess.d.ts.map

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":";AAOA;;;;;;GAMG;AACH,+DAJW,MAAM,8BAyKhB"}
+{"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,OA0XF"}

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

@@ -1 +1 @@
-{"version":3,"file":"getFullFilePath.d.ts","sourceRoot":"","sources":["../../../../src/utils/paths/getFullFilePath.js"],"names":[],"mappings":";AA+BA,gEAIC;;;;AAED;;;;;;GAMG;AACH,6DALW,MAAM,UACN,MAAM,cACN,MAAM,GACJ;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAC,CAY9E;AA/CD;;;;;GAKG;AACH,gDAJW,MAAM,YACN,MAAM,GACJ,MAAM,CAkBlB"}
+{"version":3,"file":"getFullFilePath.d.ts","sourceRoot":"","sources":["../../../../src/utils/paths/getFullFilePath.js"],"names":[],"mappings":";AAmCA,gEAIC;;;;AAED;;;;;;GAMG;AACH,6DALW,MAAM,UACN,MAAM,cACN,MAAM,GACJ;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAC,CAY9E;AAnDD;;;;;GAKG;AACH,gDAJW,MAAM,YACN,MAAM,GACJ,MAAM,CAsBlB"}

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/regex/index.js"],"names":[],"mappings":";;IAgEQ,wCAAwC;;IAGpC,mCAAkC;;AAnE9C;;GAEG;AAGH,qCAA0D;AAC1D,0CAAgE;AAChE,sCAAiE;AA+DjE;;;;GAIG;AACH,wCAHW,MAAM,EAAE,GACN,MAAM,CAKlB;AArED;;;;;;GAMG;AACH,uCAHW,MAAM,GACJ,GAAG,CA0Cf"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/utils/regex/index.js"],"names":[],"mappings":";;IA+EQ,wCAAwC;;IAGpC,mCAAkC;;AAlF9C;;GAEG;AAGH,qCAA0D;AAC1D,0CAAgE;AAChE,sCAAiE;AA8EjE;;;;GAIG;AACH,wCAHW,MAAM,EAAE,GACN,MAAM,CAKlB;AApFD;;;;;;GAMG;AACH,uCAHW,MAAM,GACJ,GAAG,CAyDf"}

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

@@ -0,0 +1,30 @@
+/**
+ * Find index of a character/pattern outside of quoted strings
+ * @param {string} str - String to search
+ * @param {string|function} matcher - Char to find, or function(str, idx) => matchLength|0
+ * @param {number} [startIdx=0] - Start index
+ * @returns {number} Index of match, or -1 if not found
+ */
+export function findOutsideQuotes(str: string, matcher: string | Function, startIdx?: number): number;
+/**
+ * Replace a pattern only outside of quoted strings
+ * @param {string} str - String to process
+ * @param {string|RegExp} pattern - Pattern to match (if string, must be exact match)
+ * @param {string|function} replacement - Replacement string or function(match) => string
+ * @returns {string} Processed string
+ */
+export function replaceOutsideQuotes(str: string, pattern: string | RegExp, replacement: string | Function): string;
+/**
+ * Check if an index is inside a quoted string
+ * @param {string} str - String to check
+ * @param {number} idx - Index to check
+ * @returns {boolean} True if index is inside quotes
+ */
+export function isInsideQuotes(str: string, idx: number): boolean;
+/**
+ * Get ranges of quoted strings in a string
+ * @param {string} str - String to analyze
+ * @returns {Array<[number, number]>} Array of [start, end] ranges
+ */
+export function getQuoteRanges(str: string): Array<[number, number]>;
+//# sourceMappingURL=quoteAware.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"quoteAware.d.ts","sourceRoot":"","sources":["../../../../src/utils/strings/quoteAware.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,uCALW,MAAM,WACN,MAAM,WAAS,aACf,MAAM,GACJ,MAAM,CAyBlB;AAED;;;;;;GAMG;AACH,0CALW,MAAM,WACN,MAAM,GAAC,MAAM,eACb,MAAM,WAAS,GACb,MAAM,CA4ClB;AAED;;;;;GAKG;AACH,oCAJW,MAAM,OACN,MAAM,GACJ,OAAO,CAiBnB;AAED;;;;GAIG;AACH,oCAHW,MAAM,GACJ,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAsBnC"}

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":"AAEA;;;;;;GAMG;AACH,wCALW,MAAM,YACN,MAAM,UACN,MAAM,GACJ,MAAM,CAMlB"}
+{"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/utils/strings/splitByComma.d.ts

@@ -1,2 +1,2 @@
-export function splitByComma(string: any, regexPattern: any): string[];
+export function splitByComma(string: any, regexPattern: any): any[];
 //# sourceMappingURL=splitByComma.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"splitByComma.d.ts","sourceRoot":"","sources":["../../../../src/utils/strings/splitByComma.js"],"names":[],"mappings":"AAiBA,uEAsFC"}
+{"version":3,"file":"splitByComma.d.ts","sourceRoot":"","sources":["../../../../src/utils/strings/splitByComma.js"],"names":[],"mappings":"AAiBA,oEAgGC"}

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

@@ -0,0 +1,8 @@
+/**
+ * Splits a string on single pipe (|) characters while preserving double pipes (||).
+ * This is needed for filter parsing since || is a logical operator, not a filter delimiter.
+ * @param {string} str - String to split
+ * @returns {string[]} - Array of parts split on single |
+ */
+export function splitOnPipe(str: string): string[];
+//# sourceMappingURL=splitOnPipe.d.ts.map