configorama 0.9.12 → 0.9.13

package/src/utils/lodash.js

@@ -1,21 +1,70 @@
-const isArray = require('lodash.isarray')
-const isString = require('lodash.isstring')
-const isNumber = require('lodash.isnumber')
-const isObject = require('lodash.isobject')
-const isDate = require('lodash.isdate')
-const isRegExp = require('lodash.isregexp')
-const isFunction = require('lodash.isfunction')
-const isEmpty = require('lodash.isempty')
+// Native replacements for lodash utilities used across the codebase
+const isArray = Array.isArray
+const isString = (val) => typeof val === 'string'
+const isNumber = (val) => typeof val === 'number' && !isNaN(val)
+const isObject = (val) => val != null && typeof val === 'object'
+const isDate = (val) => val instanceof Date
+const isRegExp = (val) => val instanceof RegExp
+const isFunction = (val) => typeof val === 'function'
+
+/**
+ * @param {*} val
+ * @returns {boolean}
+ */
+function isEmpty(val) {
+  if (val == null) return true
+  if (isArray(val) || isString(val)) return val.length === 0
+  if (val instanceof Map || val instanceof Set) return val.size === 0
+  if (isObject(val)) return Object.keys(val).length === 0
+  return false
+}
+
+// Non-trivial utilities kept as dependencies
 const camelCase = require('lodash.camelcase')
 const kebabCase = require('lodash.kebabcase')
-const capitalize = require('lodash.capitalize')
-const split = require('lodash.split')
-const map = require('lodash.map')
-const mapValues = require('lodash.mapvalues')
-const assign = require('lodash.assign')
 const cloneDeep = require('lodash.clonedeep')
 
-// Custom implementation of lodash.set
+/**
+ * @param {string} str
+ * @returns {string}
+ */
+function capitalize(str) {
+  if (!str) return ''
+  const s = String(str)
+  return s.charAt(0).toUpperCase() + s.slice(1).toLowerCase()
+}
+
+/**
+ * @param {*[]} arr
+ * @param {Function} fn
+ * @returns {*[]}
+ */
+function map(arr, fn) {
+  if (arr == null) return []
+  return Array.prototype.map.call(arr, fn)
+}
+
+/**
+ * @param {Object} obj
+ * @param {Function} fn
+ * @returns {Object}
+ */
+function mapValues(obj, fn) {
+  if (obj == null) return {}
+  const result = {}
+  const keys = Object.keys(obj)
+  for (let i = 0; i < keys.length; i++) {
+    result[keys[i]] = fn(obj[keys[i]], keys[i], obj)
+  }
+  return result
+}
+
+/**
+ * @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
+ */
 function set(object, path, value) {
   if (object === null || typeof object !== 'object') {
     return object;
@@ -37,7 +86,8 @@ function set(object, path, value) {
     // Check if value is undefined, null, or not an object (primitives can't have properties)
     if (current[key] == null || typeof current[key] !== 'object') {
       // Create appropriate container based on next key type
-      current[key] = Number.isInteger(keys[i + 1]) && keys[i + 1] >= 0 ? [] : {}
+      const nextKey = keys[i + 1]
+      current[key] = Number.isInteger(nextKey) && /** @type {number} */ (nextKey) >= 0 ? [] : {}
     }
     
     current = current[key]
@@ -50,7 +100,11 @@ function set(object, path, value) {
 // Cache for trim regex patterns (perf: avoid recompilation)
 const trimRegexCache = new Map()
 
-// Custom implementation of lodash.trim
+/**
+ * @param {string} string - String to trim
+ * @param {string} [chars] - Characters to trim (defaults to whitespace)
+ * @returns {string}
+ */
 function trim(string, chars) {
   if (string === null || string === undefined) {
     return '';
@@ -94,10 +148,10 @@ module.exports = {
   camelCase,
   kebabCase,
   capitalize,
-  split,
+  split: (str, sep) => String(str).split(sep),
   map,
   mapValues,
-  assign,
+  assign: Object.assign,
   set,
   cloneDeep,
 }

package/src/utils/parsing/cloudformationSchema.js

@@ -1,8 +1,5 @@
 const YAML = require('js-yaml');
-const includes = require('lodash.includes');
-const isString = require('lodash.isstring');
-const flatten = require('lodash.flatten');
-const map = require('lodash.map');
+const { isString } = require('../lodash')
 
 const functionNames = [
   // Standard intrinsic functions
@@ -36,7 +33,7 @@ const functionNames = [
 ];
 
 const yamlType = (name, kind) => {
-  const functionName = includes(['Ref', 'Condition'], name) ? name : `Fn::${name}`;
+  const functionName = ['Ref', 'Condition'].includes(name) ? name : `Fn::${name}`;
   return new YAML.Type(`!${name}`, {
     kind,
     construct: data => {
@@ -61,11 +58,9 @@ const yamlType = (name, kind) => {
 };
 
 const createSchema = () => {
-  const types = flatten(
-    map(functionNames, functionName =>
-      map(['mapping', 'scalar', 'sequence'], kind => yamlType(functionName, kind))
-    )
-  );
+  const types = functionNames.flatMap(functionName =>
+    ['mapping', 'scalar', 'sequence'].map(kind => yamlType(functionName, kind))
+  )
   return YAML.Schema.create(YAML.DEFAULT_SAFE_SCHEMA, types);
 };
 

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

package/src/utils/regex/index.js

@@ -93,11 +93,16 @@ 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

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, 

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,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,CA8vBxB;IA3vBC,aAA4B;IAc1B,2BAA4B;IAmB1B,sBAA0C;IAC1C,4BAAkC;IA2tBxC;;;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/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":"AAoViB;;;;;;;;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/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"}