configorama 0.9.12 → 0.9.14

package/src/utils/parsing/getValueAtPath.js

@@ -0,0 +1,111 @@
+/* Extract value from object/array using jq-style path syntax */
+
+/**
+ * Parse a jq-style path string into an array of keys/indices
+ * @param {string} path - jq-style path like '.foo.bar[0]' or '.["key"]'
+ * @returns {(string|number)[]} Array of path segments
+ */
+function parsePath(path) {
+  if (!path || typeof path !== 'string') return []
+
+  path = path.trim()
+
+  // Handle identity or empty
+  if (path === '.' || path === '') return []
+
+  // Remove leading dot if present
+  if (path.startsWith('.')) {
+    path = path.slice(1)
+  }
+
+  const segments = []
+  let i = 0
+
+  while (i < path.length) {
+    // Skip leading dots (from chained access like .foo.bar)
+    if (path[i] === '.') {
+      i++
+      continue
+    }
+
+    // Bracket notation: [0], [-1], ["key"], ['key']
+    if (path[i] === '[') {
+      const closeIdx = path.indexOf(']', i)
+      if (closeIdx === -1) {
+        throw new Error(`Unclosed bracket in path: ${path}`)
+      }
+
+      let content = path.slice(i + 1, closeIdx)
+
+      // Check if it's a quoted string key
+      if ((content.startsWith('"') && content.endsWith('"')) ||
+          (content.startsWith("'") && content.endsWith("'"))) {
+        segments.push(content.slice(1, -1))
+      } else {
+        // It's a number index
+        const num = Number(content)
+        if (!Number.isInteger(num)) {
+          throw new Error(`Invalid array index: ${content}`)
+        }
+        segments.push(num)
+      }
+
+      i = closeIdx + 1
+      continue
+    }
+
+    // Regular identifier: read until . or [ or end
+    let end = i
+    while (end < path.length && path[end] !== '.' && path[end] !== '[') {
+      end++
+    }
+
+    if (end > i) {
+      segments.push(path.slice(i, end))
+    }
+
+    i = end
+  }
+
+  return segments
+}
+
+/**
+ * Get value from object/array at jq-style path
+ * @param {*} data - Object or array to extract from
+ * @param {string} path - jq-style path like '.foo.bar[0]'
+ * @returns {*} Value at path or undefined if not found
+ */
+function getValueAtPath(data, path) {
+  if (data === null || data === undefined) {
+    return undefined
+  }
+
+  const segments = parsePath(path)
+
+  // Identity path returns input
+  if (segments.length === 0) {
+    return data
+  }
+
+  let current = data
+
+  for (const segment of segments) {
+    if (current === null || current === undefined) {
+      return undefined
+    }
+
+    // Handle negative array indices
+    if (typeof segment === 'number' && segment < 0 && Array.isArray(current)) {
+      const idx = current.length + segment
+      current = current[idx]
+    } else {
+      current = current[segment]
+    }
+  }
+
+  return current
+}
+
+module.exports = getValueAtPath
+module.exports.parsePath = parsePath

package/src/utils/parsing/getValueAtPath.test.js

@@ -0,0 +1,152 @@
+/* Tests for jq-style path extraction from objects */
+const { test } = require('uvu')
+const assert = require('uvu/assert')
+const getValueAtPath = require('./getValueAtPath')
+
+// Basic object key access
+test('getValueAtPath: .foo returns value at key', () => {
+  const obj = { foo: 42, bar: 'hello' }
+  assert.is(getValueAtPath(obj, '.foo'), 42)
+})
+
+test('getValueAtPath: . returns entire object', () => {
+  const obj = { foo: 42 }
+  assert.equal(getValueAtPath(obj, '.'), obj)
+})
+
+test('getValueAtPath: .foo.bar returns nested value', () => {
+  const obj = { foo: { bar: 'nested' } }
+  assert.is(getValueAtPath(obj, '.foo.bar'), 'nested')
+})
+
+test('getValueAtPath: .foo.bar.baz returns deeply nested value', () => {
+  const obj = { foo: { bar: { baz: 123 } } }
+  assert.is(getValueAtPath(obj, '.foo.bar.baz'), 123)
+})
+
+// Array index access
+test('getValueAtPath: .[0] returns first array element', () => {
+  const arr = ['a', 'b', 'c']
+  assert.is(getValueAtPath(arr, '.[0]'), 'a')
+})
+
+test('getValueAtPath: .[2] returns third array element', () => {
+  const arr = ['a', 'b', 'c']
+  assert.is(getValueAtPath(arr, '.[2]'), 'c')
+})
+
+test('getValueAtPath: .[-1] returns last array element', () => {
+  const arr = ['a', 'b', 'c']
+  assert.is(getValueAtPath(arr, '.[-1]'), 'c')
+})
+
+test('getValueAtPath: .[-2] returns second to last element', () => {
+  const arr = ['a', 'b', 'c']
+  assert.is(getValueAtPath(arr, '.[-2]'), 'b')
+})
+
+// Mixed object and array access
+test('getValueAtPath: .foo[0] returns first element of array at key', () => {
+  const obj = { foo: [1, 2, 3] }
+  assert.is(getValueAtPath(obj, '.foo[0]'), 1)
+})
+
+test('getValueAtPath: .foo[0].bar returns nested object in array', () => {
+  const obj = { foo: [{ bar: 'first' }, { bar: 'second' }] }
+  assert.is(getValueAtPath(obj, '.foo[0].bar'), 'first')
+})
+
+test('getValueAtPath: .[0].name returns property of first array element', () => {
+  const arr = [{ name: 'JSON' }, { name: 'XML' }]
+  assert.is(getValueAtPath(arr, '.[0].name'), 'JSON')
+})
+
+test('getValueAtPath: complex nested path', () => {
+  const obj = {
+    users: [
+      { name: 'Alice', addresses: [{ city: 'NYC' }] },
+      { name: 'Bob', addresses: [{ city: 'LA' }, { city: 'SF' }] }
+    ]
+  }
+  assert.is(getValueAtPath(obj, '.users[1].addresses[1].city'), 'SF')
+})
+
+// Bracket notation for object keys
+test('getValueAtPath: .["foo"] returns value at key', () => {
+  const obj = { foo: 42 }
+  assert.is(getValueAtPath(obj, '.["foo"]'), 42)
+})
+
+test('getValueAtPath: .["foo-bar"] returns value at hyphenated key', () => {
+  const obj = { 'foo-bar': 'works' }
+  assert.is(getValueAtPath(obj, '.["foo-bar"]'), 'works')
+})
+
+test('getValueAtPath: .["foo.bar"] returns value at key with dot', () => {
+  const obj = { 'foo.bar': 'dotted' }
+  assert.is(getValueAtPath(obj, '.["foo.bar"]'), 'dotted')
+})
+
+// Edge cases
+test('getValueAtPath: missing key returns undefined', () => {
+  const obj = { foo: 42 }
+  assert.is(getValueAtPath(obj, '.bar'), undefined)
+})
+
+test('getValueAtPath: out of bounds array index returns undefined', () => {
+  const arr = ['a', 'b']
+  assert.is(getValueAtPath(arr, '.[10]'), undefined)
+})
+
+test('getValueAtPath: path through null returns undefined', () => {
+  const obj = { foo: null }
+  assert.is(getValueAtPath(obj, '.foo.bar'), undefined)
+})
+
+test('getValueAtPath: path through undefined returns undefined', () => {
+  const obj = {}
+  assert.is(getValueAtPath(obj, '.foo.bar'), undefined)
+})
+
+test('getValueAtPath: empty path returns input', () => {
+  const obj = { foo: 42 }
+  assert.equal(getValueAtPath(obj, ''), obj)
+})
+
+test('getValueAtPath: null input returns undefined', () => {
+  assert.is(getValueAtPath(null, '.foo'), undefined)
+})
+
+test('getValueAtPath: without leading dot still works', () => {
+  const obj = { foo: { bar: 42 } }
+  assert.is(getValueAtPath(obj, 'foo.bar'), 42)
+})
+
+// Whitespace handling
+test('getValueAtPath: handles whitespace in path', () => {
+  const obj = { foo: 42 }
+  assert.is(getValueAtPath(obj, ' .foo '), 42)
+})
+
+// Error handling for malformed input
+test('getValueAtPath: throws on malformed array index with trailing characters', () => {
+  const arr = ['a', 'b', 'c']
+  assert.throws(() => getValueAtPath(arr, '.[42abc]'), /Invalid array index/)
+})
+
+test('getValueAtPath: throws on malformed array index with leading characters', () => {
+  const arr = ['a', 'b', 'c']
+  assert.throws(() => getValueAtPath(arr, '.[abc42]'), /Invalid array index/)
+})
+
+test('getValueAtPath: throws on non-numeric array index', () => {
+  const arr = ['a', 'b', 'c']
+  assert.throws(() => getValueAtPath(arr, '.[abc]'), /Invalid array index/)
+})
+
+test('getValueAtPath: throws on decimal array index', () => {
+  const arr = ['a', 'b', 'c']
+  assert.throws(() => getValueAtPath(arr, '.[1.5]'), /Invalid array index/)
+})
+
+test.run()

package/src/utils/parsing/parse.js

@@ -66,6 +66,27 @@ function parseFileContents({ contents, filePath, varRegex, dynamicArgs }) {
       // .tf and .hcl files need HCL parsing
       configObject = HCL.parse(contents, path.basename(filePath))
     }
+  } else if (fileType.match(/\.(md|mdx|markdown|mdown|mkdn|mkd|mdwn|markdn|mdtxt|mdtext)/i)) {
+    const { extractFrontmatter } = require('../../parsers/markdown')
+    const { frontmatterContent, content, format } = extractFrontmatter(contents)
+
+    if (!frontmatterContent) {
+      configObject = {}
+    } else if (format === 'toml') {
+      configObject = TOML.parse(frontmatterContent)
+    } else if (format === 'json') {
+      configObject = JSON5.parse(frontmatterContent)
+    } else {
+      const ymlText = YAML.preProcess(frontmatterContent)
+      configObject = YAML.parse(ymlText)
+    }
+    const bodyContent = content.replace(/^\n+|\n+$/g, '')
+    if (configObject.hasOwnProperty('_content')) {
+      console.warn('configorama: frontmatter key "_content" conflicts with reserved body content key. Body stored as "_body" instead.')
+      configObject._body = bodyContent
+    } else {
+      configObject._content = bodyContent
+    }
   // TODO detect js syntax and use appropriate parser
   } else if (fileType.match(/\.(js|cjs)/i)) {
     let jsFile
@@ -82,7 +103,7 @@ function parseFileContents({ contents, filePath, varRegex, dynamicArgs }) {
         configObject = jsFile(jsArgs)
       }
     } catch (err) {
-      throw new Error(err)
+      throw err
     }
   } else if (fileType.match(/\.(ts|tsx|mts|cts)/i)) {
     try {

package/src/utils/parsing/preProcess.js

@@ -145,6 +145,11 @@ function preProcess(configObject, variableSyntax, variableTypes, options = {}) {
 
         // Comparison operators for detecting string comparison context
         const comparisonOps = ['===', '!==', '==', '!=']
+        // Pre-compile "preceded by string+op" patterns to avoid regex compilation per bare ref
+        const precededByPatterns = comparisonOps.map(op => {
+          const escaped = op.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+          return new RegExp(`["'][^"']*["']\\s*${escaped}\\s*$`)
+        })
 
         // Find and replace bare refs, skipping those inside ${...} or quoted strings
         // Only quote bare refs that are in string comparison context
@@ -171,18 +176,14 @@ function preProcess(configObject, variableSyntax, variableTypes, options = {}) {
           const afterRef = fullContent.substring(matchEnd).trimStart()
           const beforeRef = fullContent.substring(0, matchStart).trimEnd()
 
-          const isComparedToString = comparisonOps.some(op => {
+          const isComparedToString = comparisonOps.some((op, idx) => {
             // Check if followed by: op "string"
             if (afterRef.startsWith(op)) {
               const afterOp = afterRef.substring(op.length).trimStart()
               return afterOp.startsWith('"') || afterOp.startsWith("'")
             }
             // Check if preceded by: "string" op
-            for (const o of comparisonOps) {
-              const pattern = new RegExp(`["'][^"']*["']\\s*${o.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*$`)
-              if (pattern.test(beforeRef)) return true
-            }
-            return false
+            return precededByPatterns.some(p => p.test(beforeRef))
           })
 
           // Replace with var ref - quoted if string comparison, unquoted otherwise
@@ -367,11 +368,16 @@ function preProcess(configObject, variableSyntax, variableTypes, options = {}) {
    */
   function traverseAndFix(obj) {
     if (typeof obj === 'string') {
-      // First escape help() variables, convert bare refs in if(), then fix fallbacks
-      const withHelpEscaped = escapeHelpVariables(obj)
-      const withBareRefsConverted = convertBareRefsInIf(withHelpEscaped)
+      // Early exits: skip expensive processing when patterns are absent
+      const hasHelp = obj.indexOf('help(') !== -1
+      const hasEvalOrIf = obj.indexOf('if(') !== -1 || obj.indexOf('eval(') !== -1
+      const hasComma = obj.indexOf(',') !== -1
+
+      const withHelpEscaped = hasHelp ? escapeHelpVariables(obj) : obj
+      const withBareRefsConverted = hasEvalOrIf ? convertBareRefsInIf(withHelpEscaped) : withHelpEscaped
       // Skip fallback fixing for object configs (they handle bare refs differently)
-      return skipFallbackFix ? withBareRefsConverted : fixFallbacksInString(withBareRefsConverted)
+      if (skipFallbackFix || !hasComma) return withBareRefsConverted
+      return fixFallbacksInString(withBareRefsConverted)
     }
 
     if (Array.isArray(obj)) {

package/src/utils/regex/index.js

@@ -2,11 +2,6 @@
  * Shared regex patterns and utilities
  */
 
-// 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
@@ -93,13 +88,15 @@ function combineRegexes(regexes) {
   return new RegExp(`(${patterns.join('|')})`)
 }
 
+const fileRefSyntax = /^file\((~?[@\{\}\:\$a-zA-Z0-9._\-\/\\%,'" =+]+?)\)/g
+const textRefSyntax = /^text\((~?[@\{\}\:\$a-zA-Z0-9._\-\/\\%,'" =+]+?)\)/g
+
 module.exports = {
   funcRegex,
-  funcRegexSimple,
-  funcStartOfLineRegex,
-  subFunctionRegex,
+  fileRefSyntax,
+  textRefSyntax,
   combineRegexes,
   parseFunctionCall,
-  // Keep old export name for backwards compat
+  // Alias used by valueFromGit
   functionRegex: funcRegex
 }

package/src/utils/ui/configWizard.js

@@ -541,7 +541,7 @@ async function runConfigWizard(metadata, originalConfig = {}, configFilePath = '
 
       if (p.isCancel(value)) {
         p.cancel('Setup cancelled')
-        process.exit(0)
+        throw new Error('Setup cancelled')
       }
 
       userInputs.options[varInfo.cleanName] = value || varInfo.defaultValue
@@ -595,7 +595,7 @@ async function runConfigWizard(metadata, originalConfig = {}, configFilePath = '
 
       if (p.isCancel(value)) {
         p.cancel('Setup cancelled')
-        process.exit(0)
+        throw new Error('Setup cancelled')
       }
 
       userInputs.env[varInfo.cleanName] = value || varInfo.resolvedValue || varInfo.defaultValue
@@ -637,7 +637,7 @@ async function runConfigWizard(metadata, originalConfig = {}, configFilePath = '
 
       if (p.isCancel(value)) {
         p.cancel('Setup cancelled')
-        process.exit(0)
+        throw new Error('Setup cancelled')
       }
 
       userInputs.self[varInfo.cleanName] = value || varInfo.defaultValue
@@ -679,7 +679,7 @@ async function runConfigWizard(metadata, originalConfig = {}, configFilePath = '
 
       if (p.isCancel(value)) {
         p.cancel('Setup cancelled')
-        process.exit(0)
+        throw new Error('Setup cancelled')
       }
 
       userInputs.dotProp[varInfo.cleanName] = value || varInfo.defaultValue

package/src/utils/validation/warnIfNotFound.js

@@ -1,8 +1,12 @@
 /**
  * Warns if a variable value is not found during resolution
  */
-const isEmpty = require('lodash.isempty')
+const { isEmpty } = require('../lodash')
 
+/**
+ * @param {*} val
+ * @returns {boolean}
+ */
 function isValidValue(val) {
   if (val !== null && typeof val === 'object' && (val.hasOwnProperty('__internal_only_flag') || val.hasOwnProperty('__internal_metadata'))) {
     return false

package/src/utils/variables/cleanVariable.js

@@ -1,5 +1,5 @@
 const { findNestedVariables } = require('./findNestedVariables')
-const { functionRegex } = require('../regex')
+const { functionRegex, fileRefSyntax } = require('../regex')
 
 const DEBUG = false
 /**
@@ -8,8 +8,6 @@ const DEBUG = false
  * @param match The variable match instance variable part
  * @returns {string} The cleaned variable match
  */
-
-const fileRefSyntax = RegExp(/^file\((~?[a-zA-Z0-9._\-\/,'" ]+?)\)/g)
 module.exports = function cleanVariable(
   match, 
   variableSyntax, 
@@ -60,27 +58,6 @@ module.exports = function cleanVariable(
     console.log(`Clean output [${caller}]`, clean)
   }
   return clean
-
-  // Support for simple variable cleaning with no space tweaks
-  if (simple) {
-    return clean
-  }
-
-  // Support for function matches that dont need space alterations
-  if (!clean.match(fileRefSyntax) && functionRegex.exec(clean)) {
-    return clean
-  }
-
-  // If file ref, add spaces after commas
-  // Special case for file(thing, arg, argTwo)
-  if (clean.match(fileRefSyntax)) {
-    // replace spaces before and after commas
-    return clean.replace(/\s*,\s*/g, ', ')
-  }
-
-  return clean.replace(/\s+(?=([^"']*"[^"']*")*[^"']*$)/g, '')
-  // ^ trim White Space OutSide Quotes https://regex101.com/r/BuBNPN/1
-  // Needed for fallback values with spaces. ${empty, 'fallback value with space'}
 }
 
 

package/types/src/main.d.ts

@@ -57,6 +57,8 @@ declare class Configorama {
     init(cliOpts: any): Promise<any>;
     options: any;
     configFileContents: string;
+    _markdownContent: any;
+    _markdownContentKey: string;
     /**
      * 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":";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"}
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/main.js"],"names":[],"mappings":";AA0GA;IACE,0CA2dC;IAndC,cAcW;IAuBX,gBAAqB;IAErB,mCAAoC;IAEpC,sBAAwB;IACxB,qBAAuB;IAGvB,uBAA4B;IAsB5B,uBAAoC;IAIpC,kBAAqC;IACrC,kBAAqC;IAErC,yBAA+F;IAC/F,yBAAuD;IACvD,kCAAyE;IAKvE,uBAAgD;IAKhD,YAAuB;IAEvB,oBAA0C;IAE1C,gBAAoD;IAOpD,uBAAkC;IAElC,uBAA8B;IAE9B,uBAAkC;IASpC,wBAAmC;IAGnC,mBAqHC;IAwED,4BAA8C;IAG9C,iCAAkC;IAalC,aA2EC;IAUD,oBAEC;IAGD,eAiDC;IAOD,YAAc;IACd,cAAgB;IAChB,kBAAkB;IAGpB;;;;OAIG;IACH,0BAHW,MAAM,GACJ,OAAO,CAQnB;IAED;;;;OAIG;IACH,6BAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAOvB;IAED;;;;OAIG;IACH,gCAHW,MAAM,GACJ,OAAO,CA2BnB;IAKD;;;;;OAKG;IACH,oBAFa,OAAO,CAAC,GAAG,CAAC,CA6vBxB;IA1vBC,aAA4B;IAc1B,2BAA4B;IAmB1B,sBAA0C;IAC1C,4BAAkC;IA0tBxC;;;OAGG;IACH,2BAFa,MAAM,CA6alB;IAvBC;;;;;;;;;;;;;;;MAoBC;IAIH;;;;OAIG;IACH,uCAFa,OAAO,CAAC,GAAG,CAAC,CAIxB;IACD,+CAsBC;IAKD;;;;;;;;;;;;;;;;;;;OAmBG;IACH;;;;;;;;;;;OAWG;IACH,mFAHa;;;;cAZC,QAAQ;;;;eACR,IAAI,GAAC,MAAM,SAAO;OAWD,CA6E9B;IACD;;;OAGG;IACH;;;;;OAKG;IACH,oCAHa,OAAO,CAAC;;;;cAjGP,QAAQ;;;;eACR,IAAI,GAAC,MAAM,SAAO;OAgGgB,CAAC,EAAE,CA6BlD;IACD;;;;;OAKG;IACH,iDAFa,OAAO,CAAC,IAAI,CAAC,CAWzB;IAID;;;;;OAKG;IACH;;;;OAIG;IACH,2BAFa,eAAc;;;;;;;;;;OAAa,CAavC;IACD;;;;;OAKG;IACH,yBAHW;;;;;;;;;;OAAa,gCACX,cAAS,CAOrB;IACD;;;;;;OAMG;IACH,6DAFa,GAAC,CAiLb;IAKD;;;;;;;OAOG;IACH,yDAHa,OAAO,CAAC,GAAG,CAAC,CAiCxB;IACD;;;;OAIG;IAOH;;;;;;OAMG;IACH,wFA2BC;IACD;;;;;;;;;;;OAWG;IACH,8BARG;QAAyB,KAAK,EAAtB,GAAG;QACoB,IAAI,GAA3B,MAAM,EAAE;QACa,cAAc,GAAnC,MAAM;QACc,iBAAiB;KAC7C,6CAEU;QAAC,KAAK,EAAE,GAAG,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAC;QAAC,iBAAiB,CAAC,QAAQ;QAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAC,CAsa9J;IAID;;;;;;;;OAQG;IACH,qEAHa,OAAO,CAAC,GAAG,CAAC,CAoExB;IAKD;;;;;;;OAOG;IACH,0FAFa,OAAO,CAAC,GAAG,CAAC,CAiiBxB;IACD,+EA+BC;IACD,yDAiBC;IACD,oEA6BC;IAKD,8CAQC;IACD,kDAyBC;IACD;;;;;;;;;;;;;OAaG;IACH,wEAoDC;IAKD,4BAOC;IACD,sCAqEC;CACF"}

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

@@ -0,0 +1,17 @@
+/**
+ * Extract frontmatter and body content from a markdown file
+ * @param {string} fileContents - Full file contents
+ * @returns {{ frontmatterContent: string|null, content: string, format: 'yaml'|'toml'|'json'|null }}
+ */
+export function extractFrontmatter(fileContents: string): {
+    frontmatterContent: string | null;
+    content: string;
+    format: "yaml" | "toml" | "json" | null;
+};
+/**
+ * Detect frontmatter syntax format from raw content
+ * @param {string} rawFrontmatter - Raw frontmatter string (without delimiters)
+ * @returns {'yaml'|'toml'|'json'} Detected format
+ */
+export function detectSyntax(rawFrontmatter: string): "yaml" | "toml" | "json";
+//# sourceMappingURL=markdown.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.d.ts","sourceRoot":"","sources":["../../../src/parsers/markdown.js"],"names":[],"mappings":"AAkBA;;;;GAIG;AACH,iDAHW,MAAM,GACJ;IAAE,kBAAkB,EAAE,MAAM,GAAC,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,GAAC,MAAM,GAAC,MAAM,GAAC,IAAI,CAAA;CAAE,CA0CnG;AA7DD;;;;GAIG;AACH,6CAHW,MAAM,GACJ,MAAM,GAAC,MAAM,GAAC,MAAM,CAWhC"}

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

@@ -1,5 +1,5 @@
 declare const envRefSyntax: RegExp;
-declare function getValueFromEnv(variableString: any): Promise<string | NodeJS.ProcessEnv>;
+declare function getValueFromEnv(variableString: any): Promise<string>;
 export declare let type: string;
 export declare let source: string;
 export declare let syntax: string;

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

@@ -1 +1 @@
-{"version":3,"file":"valueFromEnv.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromEnv.js"],"names":[],"mappings":"AACA,mCAAqC;AAErC,2FAmBC"}
+{"version":3,"file":"valueFromEnv.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromEnv.js"],"names":[],"mappings":"AAGA,mCAAqC;AAErC,uEAcC"}

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

@@ -1 +1 @@
-{"version":3,"file":"valueFromGit.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromGit.js"],"names":[],"mappings":"AAiViB;;;;;;;;EAUhB"}
+{"version":3,"file":"valueFromGit.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromGit.js"],"names":[],"mappings":"AA2XiB;;;;;;;;EAUhB"}

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

@@ -1,5 +1,13 @@
-declare function isNumberVariable(variableString: any): any;
-declare function getValueFromNumber(variableString: any): Promise<number>;
+/**
+ * @param {string} variableString
+ * @returns {boolean}
+ */
+declare function isNumberVariable(variableString: string): boolean;
+/**
+ * @param {string} variableString
+ * @returns {Promise<number>}
+ */
+declare function getValueFromNumber(variableString: string): Promise<number>;
 export declare let type: string;
 export declare let internal: boolean;
 export { isNumberVariable as match, getValueFromNumber as resolver };

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,4DAMC;AAED,0EAEC"}
+{"version":3,"file":"valueFromNumber.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromNumber.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,kDAHW,MAAM,GACJ,OAAO,CAQnB;AAED;;;GAGG;AACH,oDAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAI3B"}

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

@@ -1 +1 @@
-{"version":3,"file":"valueFromOptions.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromOptions.js"],"names":[],"mappings":"AACA,mCAAqC;AAErC,sFASC"}
+{"version":3,"file":"valueFromOptions.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromOptions.js"],"names":[],"mappings":"AAEA,mCAAqC;AAErC,sFAIC"}

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

@@ -1 +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"}
+{"version":3,"file":"valueFromParam.d.ts","sourceRoot":"","sources":["../../../src/resolvers/valueFromParam.js"],"names":[],"mappings":"AAEA,qCAAyC;AAEzC;;;;;;;;;;GAUG;AACH,mDALW,MAAM,gCAGJ,OAAO,CAAC,GAAG,CAAC,CAqExB"}

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,4CAqDC"}
+{"version":3,"file":"handleSignalEvents.d.ts","sourceRoot":"","sources":["../../../src/utils/handleSignalEvents.js"],"names":[],"mappings":";AAGA,4CAgDC"}

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

@@ -1,4 +1,51 @@
-export function trim(string: any, chars: any): any;
-export function set(object: any, path: any, value: any): any;
-export { isArray, isString, isNumber, isObject, isDate, isRegExp, isFunction, isEmpty, camelCase, kebabCase, capitalize, split, map, mapValues, assign, cloneDeep };
+export const isArray: (arg: any) => arg is any[];
+export function isString(val: any): val is string;
+export function isNumber(val: any): boolean;
+export function isObject(val: any): boolean;
+export function isDate(val: any): val is Date;
+export function isRegExp(val: any): val is RegExp;
+export function isFunction(val: any): boolean;
+/**
+ * @param {*} val
+ * @returns {boolean}
+ */
+export function isEmpty(val: any): boolean;
+/**
+ * @param {string} string - String to trim
+ * @param {string} [chars] - Characters to trim (defaults to whitespace)
+ * @returns {string}
+ */
+export function trim(string: string, chars?: string): string;
+/**
+ * @param {string} str
+ * @returns {string}
+ */
+export function capitalize(str: string): string;
+/**
+ * @param {*[]} arr
+ * @param {Function} fn
+ * @returns {*[]}
+ */
+export function map(arr: any[], fn: Function): any[];
+/**
+ * @param {Object} obj
+ * @param {Function} fn
+ * @returns {Object}
+ */
+export function mapValues(obj: any, fn: Function): any;
+/**
+ * @param {Object} object - Target object
+ * @param {string|string[]} path - Dot-delimited path or array of keys
+ * @param {*} value - Value to set
+ * @returns {Object} The mutated object
+ */
+export function set(object: any, path: string | string[], value: any): any;
+export declare function split(str: any, sep: any): string[];
+export declare let assign: {
+    <T extends {}, U>(target: T, source: U): T & U;
+    <T extends {}, U, V>(target: T, source1: U, source2: V): T & U & V;
+    <T extends {}, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;
+    (target: object, ...sources: any[]): any;
+};
+export { camelCase, kebabCase, cloneDeep };
 //# sourceMappingURL=lodash.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"lodash.d.ts","sourceRoot":"","sources":["../../../src/utils/lodash.js"],"names":[],"mappings":"AAqDA,mDA4BC;AA/DD,6DA6BC"}
+{"version":3,"file":"lodash.d.ts","sourceRoot":"","sources":["../../../src/utils/lodash.js"],"names":[],"mappings":"AACA,iDAA6B;AAC7B,kDAAiD;AACjD,4CAAgE;AAChE,4CAAgE;AAChE,8CAA2C;AAC3C,kDAA+C;AAC/C,8CAAqD;AAErD;;;GAGG;AACH,6BAHW,GAAC,GACC,OAAO,CAQnB;AAmFD;;;;GAIG;AACH,6BAJW,MAAM,UACN,MAAM,GACJ,MAAM,CA8BlB;AA7GD;;;GAGG;AACH,gCAHW,MAAM,GACJ,MAAM,CAMlB;AAED;;;;GAIG;AACH,yBAJW,GAAC,EAAE,iBAED,GAAC,EAAE,CAKf;AAED;;;;GAIG;AACH,uDAQC;AAED;;;;;GAKG;AACH,uCAJW,MAAM,GAAC,MAAM,EAAE,SACf,GAAC,OAiCX;AAqDQ,4DAAoC"}

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

@@ -0,0 +1,18 @@
+export = getValueAtPath;
+/**
+ * Get value from object/array at jq-style path
+ * @param {*} data - Object or array to extract from
+ * @param {string} path - jq-style path like '.foo.bar[0]'
+ * @returns {*} Value at path or undefined if not found
+ */
+declare function getValueAtPath(data: any, path: string): any;
+declare namespace getValueAtPath {
+    export { parsePath };
+}
+/**
+ * Parse a jq-style path string into an array of keys/indices
+ * @param {string} path - jq-style path like '.foo.bar[0]' or '.["key"]'
+ * @returns {(string|number)[]} Array of path segments
+ */
+declare function parsePath(path: string): (string | number)[];
+//# sourceMappingURL=getValueAtPath.d.ts.map