configorama 0.9.0 → 0.9.5

package/src/utils/regex/index.js

@@ -2,10 +2,72 @@
  * Shared regex patterns and utilities
  */
 
-const funcRegex = /(\w+)\s*\(((?:[^()]+)*)?\s*\)\s*/
+// Legacy regex patterns (can't handle nested parentheses properly)
+const funcRegexSimple = /(\w+)\s*\(((?:[^()]+)*)?\s*\)\s*/
 const funcStartOfLineRegex = /^(\w+)\s*\(((?:[^()]+)*)?\s*\)\s*/
 const subFunctionRegex = /(\w+):(\w+)\s*\(((?:[^()]+)*)?\s*\)\s*/
 
+/**
+ * Parse a function call with balanced parentheses support
+ * Returns a regex-exec-like array: [fullMatch, funcName, args] with index and input properties
+ * or null if no function found
+ * @param {string} str - String to search for function call
+ * @returns {any} Regex-like result array or null
+ */
+function parseFunctionCall(str) {
+  if (!str || typeof str !== 'string') return null
+  
+  // Find function name followed by opening paren
+  const funcMatch = str.match(/(\w+)\s*\(/)
+  if (!funcMatch) return null
+  
+  const funcName = funcMatch[1]
+  const openParenIndex = funcMatch.index + funcMatch[0].length - 1
+  const startPos = openParenIndex + 1
+  
+  let depth = 1
+  let pos = startPos
+  
+  // 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--
+    pos++
+  }
+  
+  if (depth !== 0) return null // Unbalanced parens
+  
+  const args = str.substring(startPos, pos - 1).trim()
+  
+  // Skip trailing whitespace for fullMatch
+  let endPos = pos
+  while (endPos < str.length && /\s/.test(str[endPos])) {
+    endPos++
+  }
+  
+  const fullMatch = str.substring(funcMatch.index, endPos)
+  
+  // Create regex-exec-like result array with index and input properties
+  /** @type {any} */
+  const result = [fullMatch, funcName, args || undefined]
+  result.index = funcMatch.index
+  result.input = str
+  return result
+}
+
+/**
+ * Enhanced funcRegex that handles nested parentheses
+ * Mimics RegExp interface with exec() method
+ */
+const funcRegex = {
+  exec: parseFunctionCall,
+  test: (str) => parseFunctionCall(str) !== null,
+  // Keep source for compatibility (shows what pattern we're conceptually matching)
+  source: '(\\w+)\\s*\\((.*)\\)\\s*',
+  toString: () => '/(\\w+)\\s*\\((.*)\\)\\s*/'
+}
+
 /**
  * Combine multiple regex patterns into single OR pattern
  * @param {RegExp[]} regexes - Array of regex patterns to combine
@@ -18,9 +80,11 @@ function combineRegexes(regexes) {
 
 module.exports = {
   funcRegex,
+  funcRegexSimple,
   funcStartOfLineRegex,
   subFunctionRegex,
   combineRegexes,
+  parseFunctionCall,
   // Keep old export name for backwards compat
   functionRegex: funcRegex
 }

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

@@ -0,0 +1,195 @@
+/**
+ * Tests for regex utilities - especially funcRegex with nested parentheses
+ */
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const { funcRegex, parseFunctionCall } = require('./index')
+
+// ==========================================
+// parseFunctionCall - basic functionality
+// ==========================================
+
+test('parseFunctionCall - simple function with no args', () => {
+  const result = parseFunctionCall('myFunc()')
+  assert.ok(result)
+  assert.is(result[1], 'myFunc')
+  assert.is(result[2], undefined)
+})
+
+test('parseFunctionCall - simple function with string arg', () => {
+  const result = parseFunctionCall("help('some text')")
+  assert.ok(result)
+  assert.is(result[1], 'help')
+  assert.is(result[2], "'some text'")
+})
+
+test('parseFunctionCall - function with multiple args', () => {
+  const result = parseFunctionCall("merge('a', 'b')")
+  assert.ok(result)
+  assert.is(result[1], 'merge')
+  assert.is(result[2], "'a', 'b'")
+})
+
+test('parseFunctionCall - returns null for non-function string', () => {
+  const result = parseFunctionCall('not a function')
+  assert.is(result, null)
+})
+
+test('parseFunctionCall - returns null for null input', () => {
+  const result = parseFunctionCall(null)
+  assert.is(result, null)
+})
+
+test('parseFunctionCall - returns null for undefined input', () => {
+  const result = parseFunctionCall(undefined)
+  assert.is(result, null)
+})
+
+// ==========================================
+// parseFunctionCall - nested parentheses (bug fix)
+// ==========================================
+
+test('parseFunctionCall - handles parentheses in text argument', () => {
+  const result = parseFunctionCall("help('Deployment stage (dev, staging, prod)')")
+  assert.ok(result)
+  assert.is(result[1], 'help')
+  assert.is(result[2], "'Deployment stage (dev, staging, prod)'")
+})
+
+test('parseFunctionCall - handles nested function calls', () => {
+  const result = parseFunctionCall('outer(inner(arg))')
+  assert.ok(result)
+  assert.is(result[1], 'outer')
+  assert.is(result[2], 'inner(arg)')
+})
+
+test('parseFunctionCall - handles multiple nested function args', () => {
+  const result = parseFunctionCall('merge(func1(a), func2(b))')
+  assert.ok(result)
+  assert.is(result[1], 'merge')
+  assert.is(result[2], 'func1(a), func2(b)')
+})
+
+test('parseFunctionCall - handles deeply nested parentheses', () => {
+  const result = parseFunctionCall('a(b(c(d)))')
+  assert.ok(result)
+  assert.is(result[1], 'a')
+  assert.is(result[2], 'b(c(d))')
+})
+
+test('parseFunctionCall - handles complex help text with variables', () => {
+  const result = parseFunctionCall("help('Deployment stage (${allowedValues}, funky)')")
+  assert.ok(result)
+  assert.is(result[1], 'help')
+  assert.is(result[2], "'Deployment stage (${allowedValues}, funky)'")
+})
+
+test('parseFunctionCall - handles multiple parens in text', () => {
+  const result = parseFunctionCall("help('Choose option (A) or (B) or (C)')")
+  assert.ok(result)
+  assert.is(result[1], 'help')
+  assert.is(result[2], "'Choose option (A) or (B) or (C)'")
+})
+
+// ==========================================
+// parseFunctionCall - edge cases
+// ==========================================
+
+test('parseFunctionCall - handles whitespace around args', () => {
+  const result = parseFunctionCall('func(  arg  )')
+  assert.ok(result)
+  assert.is(result[1], 'func')
+  assert.is(result[2], 'arg')
+})
+
+test('parseFunctionCall - handles whitespace before opening paren', () => {
+  const result = parseFunctionCall('func  (arg)')
+  assert.ok(result)
+  assert.is(result[1], 'func')
+  assert.is(result[2], 'arg')
+})
+
+test('parseFunctionCall - returns null for unbalanced open paren', () => {
+  const result = parseFunctionCall('func((arg)')
+  assert.is(result, null)
+})
+
+test('parseFunctionCall - handles function in middle of string', () => {
+  const result = parseFunctionCall('prefix func(arg) suffix')
+  assert.ok(result)
+  assert.is(result[1], 'func')
+  assert.is(result[2], 'arg')
+})
+
+test('parseFunctionCall - includes index property', () => {
+  const result = parseFunctionCall('prefix func(arg)')
+  assert.ok(result)
+  assert.is(result.index, 7) // "prefix " is 7 chars
+})
+
+test('parseFunctionCall - includes input property', () => {
+  const input = 'func(arg)'
+  const result = parseFunctionCall(input)
+  assert.ok(result)
+  assert.is(result.input, input)
+})
+
+// ==========================================
+// funcRegex.exec - same interface as RegExp
+// ==========================================
+
+test('funcRegex.exec - works like RegExp.exec', () => {
+  const result = funcRegex.exec("help('text')")
+  assert.ok(result)
+  assert.is(result[1], 'help')
+  assert.is(result[2], "'text'")
+})
+
+test('funcRegex.exec - handles nested parens', () => {
+  const result = funcRegex.exec("outer(inner(x))")
+  assert.ok(result)
+  assert.is(result[1], 'outer')
+  assert.is(result[2], 'inner(x)')
+})
+
+test('funcRegex.test - returns true for function', () => {
+  assert.is(funcRegex.test('func()'), true)
+})
+
+test('funcRegex.test - returns false for non-function', () => {
+  assert.is(funcRegex.test('not a function'), false)
+})
+
+// ==========================================
+// Real-world examples from codebase
+// ==========================================
+
+test('real-world: split function', () => {
+  const result = funcRegex.exec("split('hello,world', ',')")
+  assert.ok(result)
+  assert.is(result[1], 'split')
+  assert.is(result[2], "'hello,world', ','")
+})
+
+test('real-world: merge function', () => {
+  const result = funcRegex.exec("merge('stuff', 'new')")
+  assert.ok(result)
+  assert.is(result[1], 'merge')
+  assert.is(result[2], "'stuff', 'new'")
+})
+
+test('real-world: nested split(merge())', () => {
+  const result = funcRegex.exec("split(merge('a', 'b'), ',')")
+  assert.ok(result)
+  assert.is(result[1], 'split')
+  assert.is(result[2], "merge('a', 'b'), ','")
+})
+
+test('real-world: git remote', () => {
+  const result = funcRegex.exec("remote('origin')")
+  assert.ok(result)
+  assert.is(result[1], 'remote')
+  assert.is(result[2], "'origin'")
+})
+
+test.run()

package/src/utils/strings/formatFunctionArgs.js

@@ -20,6 +20,10 @@ module.exports = function formatArgs(args) {
     return formatArg(args)
   }
   return args.map((arg) => {
+    // Skip formatting for non-string args (e.g., arrays/objects from nested function calls)
+    if (typeof arg !== 'string') {
+      return arg
+    }
     return formatArg(arg)
   })
 }

package/src/utils/strings/splitCsv.js

@@ -4,7 +4,7 @@ const { splitByComma } = require('./splitByComma')
 const VARIABLE_SYNTAX = /\${[^}]+}/g
 
 /**
- * Split a string by comma while preserving quoted content
+ * Split a string by delimiter while preserving quoted content and balanced parentheses
  * 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
@@ -14,26 +14,53 @@ const VARIABLE_SYNTAX = /\${[^}]+}/g
  * @returns {string[]} Array of split strings
  */
 function splitCsv(str, splitter, options = {}) {
-  // If custom splitter is provided, fall back to original simple implementation
+  // If custom splitter is provided, use implementation with parenthesis tracking
   if (splitter && splitter !== ',') {
-    const splitSyntax = splitter
-    return str.split(splitSyntax).reduce(
-      (acc, curr) => {
-        if (acc.isConcatting) {
-          acc.soFar[acc.soFar.length - 1] += splitter + curr
-        } else {
-          acc.soFar.push(curr)
+    const result = []
+    let current = ''
+    let inQuote = false
+    let quoteChar = ''
+    let parenDepth = 0
+    let bracketDepth = 0
+    
+    for (let i = 0; i < str.length; i++) {
+      const char = str[i]
+      
+      // Handle quotes
+      if ((char === "'" || char === '"') && (i === 0 || str[i-1] !== '\\')) {
+        if (!inQuote) {
+          inQuote = true
+          quoteChar = char
+        } else if (char === quoteChar) {
+          inQuote = false
         }
-        if (curr.split('"').length % 2 == 0) {
-          acc.isConcatting = !acc.isConcatting
-        }
-        return acc
-      },
-      {
-        soFar: [],
-        isConcatting: false,
-      },
-    ).soFar
+      }
+      
+      // Handle parentheses and brackets (only outside quotes)
+      if (!inQuote) {
+        if (char === '(') parenDepth++
+        else if (char === ')') parenDepth--
+        else if (char === '[') bracketDepth++
+        else if (char === ']') bracketDepth--
+      }
+      
+      // Check if we're at a splitter position
+      const atSplitter = str.substring(i, i + splitter.length) === splitter
+      
+      if (atSplitter && !inQuote && parenDepth === 0 && bracketDepth === 0) {
+        result.push(current.trim())
+        current = ''
+        i += splitter.length - 1 // Skip rest of splitter
+      } else {
+        current += char
+      }
+    }
+    
+    if (current.trim() || result.length > 0) {
+      result.push(current.trim())
+    }
+    
+    return result
   }
 
   // For standard comma splitting, use the more robust splitByComma

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

@@ -1 +1 @@
-{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/main.js"],"names":[],"mappings":";AA0GA;IACE,0CAybC;IAjbC,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;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,CA6gBxB;IACD,+EA+BC;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,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"}

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

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"mergeByKeys.d.ts","sourceRoot":"","sources":["../../../../src/utils/parsing/mergeByKeys.js"],"names":[],"mappings":"AAAA;;GAEG;AACH,yEAwBC"}
+{"version":3,"file":"mergeByKeys.d.ts","sourceRoot":"","sources":["../../../../src/utils/parsing/mergeByKeys.js"],"names":[],"mappings":"AAAA;;GAEG;AACH,yEAyBC"}

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;;;;;;eAkGf,MAAM;;;;kBACN,cAAe;;AAxG7B;;;;;;GAMG;AAEH;;;;GAIG;AACH,iFAHW,YAAY,OAyFtB;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":";;;;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"}

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

@@ -1,7 +1,13 @@
+export namespace funcRegex {
+    export { parseFunctionCall as exec };
+    export function test(str: any): boolean;
+    export let source: string;
+    export function toString(): string;
+}
 /**
  * Shared regex patterns and utilities
  */
-export const funcRegex: RegExp;
+export const funcRegexSimple: RegExp;
 export const funcStartOfLineRegex: RegExp;
 export const subFunctionRegex: RegExp;
 /**
@@ -10,5 +16,13 @@ export const subFunctionRegex: RegExp;
  * @returns {RegExp} Combined regex with OR operator
  */
 export function combineRegexes(regexes: RegExp[]): RegExp;
+/**
+ * Parse a function call with balanced parentheses support
+ * Returns a regex-exec-like array: [fullMatch, funcName, args] with index and input properties
+ * or null if no function found
+ * @param {string} str - String to search for function call
+ * @returns {any} Regex-like result array or null
+ */
+export function parseFunctionCall(str: string): any;
 export { funcRegex as functionRegex };
 //# sourceMappingURL=index.d.ts.map

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":"AAAA;;GAEG;AAEH,+BAAoD;AACpD,0CAAgE;AAChE,sCAAiE;AAEjE;;;;GAIG;AACH,wCAHW,MAAM,EAAE,GACN,MAAM,CAKlB"}
+{"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"}

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

@@ -1 +1 @@
-{"version":3,"file":"formatFunctionArgs.d.ts","sourceRoot":"","sources":["../../../../src/utils/strings/formatFunctionArgs.js"],"names":[],"mappings":"AAiBiB,0CAOhB"}
+{"version":3,"file":"formatFunctionArgs.d.ts","sourceRoot":"","sources":["../../../../src/utils/strings/formatFunctionArgs.js"],"names":[],"mappings":"AAiBiB,0CAWhB"}

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

@@ -1,5 +1,5 @@
 /**
- * Split a string by comma while preserving quoted content
+ * Split a string by delimiter while preserving quoted content and balanced parentheses
  * 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

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":"AAKA;;;;;;;;;GASG;AACH,8BANW,MAAM,aACN,MAAM,YAEd;IAA0B,gBAAgB,GAAlC,OAAO;CACf,GAAU,MAAM,EAAE,CA+BpB"}
+{"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,CA0DpB"}