configorama 0.9.5 → 0.9.11

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/validation/warnIfNotFound.js

@@ -4,7 +4,7 @@
 const isEmpty = require('lodash.isempty')
 
 function isValidValue(val) {
-  if (typeof val === 'object' && (val.hasOwnProperty('__internal_only_flag') || val.hasOwnProperty('__internal_metadata'))) {
+  if (val !== null && typeof val === 'object' && (val.hasOwnProperty('__internal_only_flag') || val.hasOwnProperty('__internal_metadata'))) {
     return false
   }
   return val !== null && typeof val !== 'undefined' && !(typeof val === 'object' && isEmpty(val))

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,0CA6bC;IArbC,cAcW;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;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,yDAeC;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/hcl-parse-script.d.ts

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

package/types/src/parsers/hcl-parse-script.d.ts.map

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

package/types/src/parsers/hcl.d.ts

@@ -1 +1,44 @@
+/**
+ * Synchronous HCL parsing using child process
+ * @param {string} hclContents - HCL string to parse
+ * @param {string} [filename='config.tf'] - Filename for context
+ * @returns {Object} Parsed HCL object
+ * @throws {Error} If HCL parsing fails
+ */
+export function parseSync(hclContents: string, filename?: string): any;
+/**
+ * Parse HCL content into JavaScript object
+ * Uses @cdktf/hcl2json to convert HCL to JSON
+ * @param {string} hclContents - HCL string to parse
+ * @param {string} [filename='config.tf'] - Filename for context
+ * @returns {Promise<Object>} Parsed HCL object
+ * @throws {Error} If HCL parsing fails
+ */
+declare function parse(hclContents: string, filename?: string): Promise<any>;
+/**
+ * Convert JavaScript object to HCL string
+ * Note: HCL generation is complex and not fully supported
+ * This is a placeholder for potential future implementation
+ * @param {Object} object - Object to convert to HCL
+ * @returns {string} HCL string representation
+ * @throws {Error} Always throws - HCL generation not implemented
+ */
+export function dump(object: any): string;
+/**
+ * Convert HCL content to YAML format
+ * @param {string} hclContents - HCL string to convert
+ * @param {string} [filename='config.tf'] - Filename for context
+ * @returns {Promise<string>} YAML string representation
+ * @throws {Error} If conversion fails
+ */
+export function toYaml(hclContents: string, filename?: string): Promise<string>;
+/**
+ * Convert HCL content to JSON format
+ * @param {string} hclContents - HCL string to convert
+ * @param {string} [filename='config.tf'] - Filename for context
+ * @returns {Promise<string>} JSON string representation
+ * @throws {Error} If conversion fails
+ */
+export function toJson(hclContents: string, filename?: string): Promise<string>;
+export { parseSync as parse, parse as parseAsync };
 //# sourceMappingURL=hcl.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"hcl.d.ts","sourceRoot":"","sources":["../../../src/parsers/hcl.js"],"names":[],"mappings":""}
+{"version":3,"file":"hcl.d.ts","sourceRoot":"","sources":["../../../src/parsers/hcl.js"],"names":[],"mappings":"AA2CA;;;;;;GAMG;AACH,uCALW,MAAM,aACN,MAAM,OA2BhB;AAlDD;;;;;;;GAOG;AACH,oCALW,MAAM,aACN,MAAM,GACJ,OAAO,KAAQ,CAa3B;AAkCD;;;;;;;GAOG;AACH,mCAHa,MAAM,CAKlB;AAED;;;;;;GAMG;AACH,oCALW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAY3B;AAED;;;;;;GAMG;AACH,oCALW,MAAM,aACN,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAY3B"}

package/types/src/parsers/hcl.slow-test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=hcl.slow-test.d.ts.map

package/types/src/parsers/hcl.slow-test.d.ts.map

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

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/valueFromFile.d.ts

@@ -12,6 +12,8 @@
  * @param {Function} ctx.getDeeperValue - Method for nested lookups
  * @param {RegExp} ctx.fileRefSyntax - Regex for file() syntax
  * @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 {string} variableString - The variable string to resolve
  * @param {object} options - Resolution options
  * @returns {Promise<any>}
@@ -28,6 +30,8 @@ export function getValueFromFile(ctx: {
     getDeeperValue: Function;
     fileRefSyntax: RegExp;
     textRefSyntax: RegExp;
+    varPrefix: string;
+    varSuffix: 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":"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,CAiUxB;AA3WD;;;;;GAKG;AACH,2CAJW,MAAM,YACN,MAAM,GACJ,GAAC,CAoBb;AAqVD;;;;;;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/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/parse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../../../src/utils/parsing/parse.js"],"names":[],"mappings":";;;;cAec,MAAM;;;;cACN,MAAM;;;;eACN,MAAM;;;;kBACN,cAAe;;;;;;eAqGf,MAAM;;;;kBACN,cAAe;;AA3G7B;;;;;;GAMG;AAEH;;;;GAIG;AACH,iFAHW,YAAY,OA4FtB;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;;;;;;eA8Gf,MAAM;;;;kBACN,cAAe;;AApH7B;;;;;;GAMG;AAEH;;;;GAIG;AACH,iFAHW,YAAY,OAqGtB;AAED;;;;GAIG;AAEH;;;;;GAKG;AACH,oCAJW,MAAM,SACN,gBAAgB,OAW1B"}

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"splitOnPipe.d.ts","sourceRoot":"","sources":["../../../../src/utils/strings/splitOnPipe.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,iCAHW,MAAM,GACJ,MAAM,EAAE,CAgBpB"}

package/types/src/utils/variables/findNestedVariables.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findNestedVariables.d.ts","sourceRoot":"","sources":["../../../../src/utils/variables/findNestedVariables.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,2CARW,MAAM,SACN,MAAM,uBACN,MAAM,YACN,MAAM,gCAEN,OAAO,SAyQjB"}
+{"version":3,"file":"findNestedVariables.d.ts","sourceRoot":"","sources":["../../../../src/utils/variables/findNestedVariables.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,2CARW,MAAM,SACN,MAAM,uBACN,MAAM,YACN,MAAM,gCAEN,OAAO,SA+QjB"}