configorama 1.1.0 → 1.2.2

package/src/utils/setup/setupEngine.js

@@ -0,0 +1,85 @@
+// Orchestrates the config setup wizard: analyze config, prompt for missing values,
+// and return grouped answers plus a redacted copy safe for display.
+const path = require('path')
+const { runConfigWizard } = require('../ui/configWizard')
+const { buildConfigRequirements } = require('../requirements/configRequirements')
+const { redactUserInputsByRequirements } = require('../redaction/setupRedaction')
+
+const ANSWER_GROUPS = /** @type {const} */ (['options', 'env', 'self', 'dotProp'])
+
+/**
+ * @typedef {Object} SetupAnswers
+ * @property {Object.<string, any>} options - answers for ${opt:...} variables
+ * @property {Object.<string, any>} env - answers for ${env:...} variables
+ * @property {Object.<string, any>} self - answers for ${self:...} variables
+ * @property {Object.<string, any>} dotProp - answers for dot-prop config references
+ */
+
+/**
+ * @typedef {Object} SetupResult
+ * @property {number} schemaVersion - result shape version
+ * @property {string|null} configPath - absolute path to the config file, null for object input
+ * @property {Array<Object>} requirements - prompt requirements from buildConfigRequirements
+ * @property {SetupAnswers} answers - raw user answers grouped by variable type
+ * @property {SetupAnswers} redactedAnswers - answers with sensitive values redacted for display
+ */
+
+/**
+ * Ensure every answer group exists so callers get a stable shape
+ * @param {Object|undefined} userInputs - answers from the prompt renderer
+ * @returns {SetupAnswers} answers with all groups present
+ */
+function normalizeAnswerGroups(userInputs) {
+  /** @type {SetupAnswers} */
+  const normalized = { options: {}, env: {}, self: {}, dotProp: {} }
+  for (const group of ANSWER_GROUPS) {
+    normalized[group] = Object.assign({}, userInputs && userInputs[group])
+  }
+  return normalized
+}
+
+/**
+ * Run the setup flow: analyze the config, prompt for unresolved values, return answers.
+ * Pure orchestration - applies nothing to process.env, config, or disk.
+ * @param {string|Object} configPathOrObject - path to config file or raw config object
+ * @param {Object} [settings] - configorama settings, plus:
+ * @param {Function} [settings.promptRenderer] - replaces the interactive wizard (mocks, answers files)
+ * @param {Object} [settings.streams] - stream overrides forwarded to the prompt renderer
+ * @param {Object} deps - injected dependencies
+ * @param {Function} [deps.analyze] - configorama.analyze, injected to avoid a require cycle
+ * @param {Object} [deps.analysis] - pre-computed analysis; skips the analyze call
+ * @returns {Promise<SetupResult>} collected answers and requirements
+ */
+async function runSetup(configPathOrObject, settings = {}, deps = {}) {
+  const { analyze } = deps
+  if (!deps.analysis && typeof analyze !== 'function') {
+    throw new Error('setup engine requires an analyze function or a pre-computed analysis')
+  }
+  const { promptRenderer, streams, ...analyzeSettings } = settings
+
+  const analysis = deps.analysis || await analyze(configPathOrObject, analyzeSettings)
+  const requirements = buildConfigRequirements(analysis)
+
+  const configPath = typeof configPathOrObject === 'string'
+    ? path.resolve(configPathOrObject)
+    : null
+
+  const renderPrompts = promptRenderer || runConfigWizard
+  const userInputs = await renderPrompts(analysis, analysis.originalConfig || {}, configPath || '', streams)
+
+  const answers = normalizeAnswerGroups(userInputs)
+  const redactedAnswers = normalizeAnswerGroups(redactUserInputsByRequirements(answers, requirements))
+
+  return {
+    schemaVersion: 1,
+    configPath,
+    requirements,
+    answers,
+    redactedAnswers,
+  }
+}
+
+module.exports = {
+  runSetup,
+  normalizeAnswerGroups,
+}

package/src/utils/setup/stdoutRedirect.js

@@ -0,0 +1,48 @@
+// Temporarily delegates process.stdout writes to another stream so interactive
+// prompt UI can render elsewhere (e.g. stderr) while stdout stays machine-clean.
+
+const MIRRORED_TTY_PROPS = ['rows', 'columns', 'isTTY']
+
+/**
+ * Run fn with all process.stdout writes forwarded to target.
+ * TTY dimensions are mirrored from target so prompt layout matches the
+ * stream it actually renders on (stdout is often a pipe in --export mode).
+ * @param {import('stream').Writable} target - stream that receives the writes
+ * @param {Function} fn - async function to run while redirected
+ * @returns {Promise<any>} fn's result
+ */
+async function withStdoutRedirected(target, fn) {
+  const originalWrite = process.stdout.write
+  const savedDescriptors = {}
+
+  process.stdout.write = /** @type {typeof process.stdout.write} */ (
+    (chunk, encoding, callback) => target.write(chunk, encoding, callback)
+  )
+
+  for (const prop of MIRRORED_TTY_PROPS) {
+    if (target[prop] === undefined) continue
+    savedDescriptors[prop] = Object.getOwnPropertyDescriptor(process.stdout, prop) || null
+    Object.defineProperty(process.stdout, prop, {
+      configurable: true,
+      enumerable: true,
+      get() { return target[prop] },
+    })
+  }
+
+  try {
+    return await fn()
+  } finally {
+    process.stdout.write = originalWrite
+    for (const [prop, descriptor] of Object.entries(savedDescriptors)) {
+      if (descriptor) {
+        Object.defineProperty(process.stdout, prop, descriptor)
+      } else {
+        delete process.stdout[prop]
+      }
+    }
+  }
+}
+
+module.exports = {
+  withStdoutRedirected,
+}

package/src/utils/setup/writeAnswers.js

@@ -0,0 +1,50 @@
+// Writes setup answers to a versioned JSON file for automation (agents, CI).
+// Answers can contain raw secrets, so writes are 0600, atomic, and overwrite-safe.
+const fs = require('fs')
+const path = require('path')
+const { ConfigoramaError } = require('../../errors')
+const { normalizeAnswerGroups } = require('./setupEngine')
+
+/**
+ * Write setup answers to a JSON file
+ * @param {string} filePath - target path
+ * @param {Object} answers - answer groups { options, env, self, dotProp }
+ * @param {Object} [opts] - write behavior
+ * @param {boolean} [opts.force] - overwrite an existing file
+ * @returns {{ path: string, groups: Object.<string, string[]> }} written target and key names per group
+ */
+function writeAnswers(filePath, answers, opts = {}) {
+  if (fs.existsSync(filePath) && !opts.force) {
+    throw new ConfigoramaError(
+      'target_file_exists',
+      `${filePath} already exists. Pass --force to overwrite.`
+    )
+  }
+
+  const normalized = normalizeAnswerGroups(answers)
+  const payload = {
+    schemaVersion: 1,
+    answers: normalized,
+  }
+
+  const dir = path.dirname(filePath)
+  const tmpPath = path.join(dir, `.${path.basename(filePath)}.configx-tmp-${process.pid}`)
+  fs.writeFileSync(tmpPath, `${JSON.stringify(payload, null, 2)}\n`, { mode: 0o600 })
+  try {
+    fs.renameSync(tmpPath, filePath)
+  } catch (err) {
+    fs.unlinkSync(tmpPath)
+    throw err
+  }
+
+  /** @type {Object.<string, string[]>} */
+  const groups = {}
+  for (const [group, values] of Object.entries(normalized)) {
+    groups[group] = Object.keys(values)
+  }
+  return { path: filePath, groups }
+}
+
+module.exports = {
+  writeAnswers,
+}

package/src/utils/setup/writeDotenv.js

@@ -0,0 +1,142 @@
+// Writes env answers to a dotenv file safely: strict key validation, quoting
+// that round-trips, 0600 permissions, managed-block merge, atomic writes.
+const fs = require('fs')
+const path = require('path')
+const { ConfigoramaError } = require('../../errors')
+
+const MANAGED_BLOCK_START = '# >>> configx setup values >>>'
+const MANAGED_BLOCK_END = '# <<< configx setup values <<<'
+
+const VALID_KEY = /^[A-Za-z_][A-Za-z0-9_]*$/
+const PLAIN_VALUE = /^[A-Za-z0-9_./:@+=-]*$/
+
+/**
+ * Quote a value so common dotenv parsers read it back verbatim
+ * @param {string} value - raw value
+ * @returns {string} dotenv-safe representation
+ */
+function quoteDotenvValue(value) {
+  const str = String(value)
+  if (PLAIN_VALUE.test(str)) return str
+  // Single quotes are literal in dotenv - no expansion of $ or escapes
+  if (!str.includes("'") && !str.includes('\n')) return `'${str}'`
+  const escaped = str
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, '\\n')
+  return `"${escaped}"`
+}
+
+/**
+ * Render KEY=value lines for the given values
+ * @param {Object.<string, any>} values - env key/value pairs
+ * @returns {string[]} dotenv lines
+ */
+function renderLines(values) {
+  return Object.entries(values).map(([key, value]) => `${key}=${quoteDotenvValue(value)}`)
+}
+
+/**
+ * Replace or append the managed block in existing dotenv content
+ * @param {string} content - current file content
+ * @param {string[]} lines - new KEY=value lines for the block
+ * @param {string} filePath - target path for error messages
+ * @returns {string} updated file content
+ */
+function mergeManagedBlock(content, lines, filePath) {
+  const startCount = content.split(MANAGED_BLOCK_START).length - 1
+  const endCount = content.split(MANAGED_BLOCK_END).length - 1
+
+  if (startCount > 1 || endCount > 1 || startCount !== endCount) {
+    throw new ConfigoramaError(
+      'managed_block_invalid',
+      `Cannot merge into ${filePath}: expected exactly one intact managed block, found ${startCount} start and ${endCount} end marker(s).`
+    )
+  }
+
+  const block = [MANAGED_BLOCK_START, ...lines, MANAGED_BLOCK_END].join('\n')
+
+  if (startCount === 0) {
+    const separator = content.length === 0 || content.endsWith('\n') ? '' : '\n'
+    return `${content}${separator}${block}\n`
+  }
+
+  const startIndex = content.indexOf(MANAGED_BLOCK_START)
+  const endIndex = content.indexOf(MANAGED_BLOCK_END)
+  if (endIndex < startIndex) {
+    throw new ConfigoramaError(
+      'managed_block_invalid',
+      `Cannot merge into ${filePath}: managed block markers are out of order.`
+    )
+  }
+  return content.slice(0, startIndex) + block + content.slice(endIndex + MANAGED_BLOCK_END.length)
+}
+
+/**
+ * Write values atomically: temp file in the same directory, then rename
+ * @param {string} filePath - target path
+ * @param {string} content - file content
+ * @param {number} mode - file mode for new files
+ */
+function atomicWrite(filePath, content, mode) {
+  const dir = path.dirname(filePath)
+  const tmpPath = path.join(dir, `.${path.basename(filePath)}.configx-tmp-${process.pid}`)
+  fs.writeFileSync(tmpPath, content, { mode })
+  try {
+    fs.renameSync(tmpPath, filePath)
+  } catch (err) {
+    fs.unlinkSync(tmpPath)
+    throw err
+  }
+}
+
+/**
+ * Write env answers to a dotenv file
+ * @param {string} filePath - target dotenv path
+ * @param {Object.<string, any>} values - env key/value pairs to write
+ * @param {Object} [opts] - write behavior
+ * @param {boolean} [opts.merge] - replace/append the managed block, preserving other content
+ * @param {boolean} [opts.force] - overwrite the whole file if it exists
+ * @returns {{ path: string, keys: string[] }} written target and key names for summaries
+ */
+function writeDotenv(filePath, values, opts = {}) {
+  const keys = Object.keys(values || {})
+  for (const key of keys) {
+    if (!VALID_KEY.test(key)) {
+      throw new ConfigoramaError(
+        'invalid_env_key',
+        `Cannot write "${key}" to ${filePath}: dotenv keys must match ${VALID_KEY}.`
+      )
+    }
+  }
+
+  const lines = renderLines(values)
+  const exists = fs.existsSync(filePath)
+
+  if (exists && !opts.merge && !opts.force) {
+    throw new ConfigoramaError(
+      'target_file_exists',
+      `${filePath} already exists. Pass --merge to update the managed block or --force to overwrite.`
+    )
+  }
+
+  let content
+  let mode = 0o600
+  if (opts.merge) {
+    const existingContent = exists ? fs.readFileSync(filePath, 'utf8') : ''
+    if (exists) mode = fs.statSync(filePath).mode & 0o777
+    content = mergeManagedBlock(existingContent, lines, filePath)
+  } else {
+    content = `${lines.join('\n')}\n`
+  }
+
+  atomicWrite(filePath, content, mode)
+  return { path: filePath, keys }
+}
+
+module.exports = {
+  writeDotenv,
+  quoteDotenvValue,
+  MANAGED_BLOCK_START,
+  MANAGED_BLOCK_END,
+}

package/src/utils/ui/configWizard.js

@@ -8,6 +8,7 @@ const { toClickablePath } = require('./createEditorLink')
 const { buildConfigRequirements } = require('../requirements/configRequirements')
 const { createPromptDescriptors } = require('./promptDescriptors')
 const { isSensitiveVariable } = require('../redaction/redact')
+const { withStdoutRedirected } = require('../setup/stdoutRedirect')
 
 const INVISIBLE_SPACE = '\u2800\u2800\u2800'
 
@@ -613,9 +614,27 @@ function createPromptMessage(varInfo) {
  * Runs config setup wizard
  * @param {object} metadata - Enriched metadata from configorama
  * @param {object} originalConfig - The original config before resolution
+ * @param {string} [configFilePath] - Path to the config file for display
+ * @param {object} [streams] - Stream overrides for the prompt UI
+ * @param {import('stream').Writable} [streams.output] - Where prompt UI renders; stdout stays clean when set
  * @returns {Promise<object>} User inputs by variable type
  */
-async function runConfigWizard(metadata, originalConfig = {}, configFilePath = '') {
+async function runConfigWizard(metadata, originalConfig = {}, configFilePath = '', streams) {
+  const output = streams && streams.output
+  if (output && output !== process.stdout) {
+    return withStdoutRedirected(output, () => renderConfigWizard(metadata, originalConfig, configFilePath))
+  }
+  return renderConfigWizard(metadata, originalConfig, configFilePath)
+}
+
+/**
+ * Renders the wizard prompts on process.stdout
+ * @param {object} metadata - Enriched metadata from configorama
+ * @param {object} originalConfig - The original config before resolution
+ * @param {string} [configFilePath] - Path to the config file for display
+ * @returns {Promise<object>} User inputs by variable type
+ */
+async function renderConfigWizard(metadata, originalConfig = {}, configFilePath = '') {
   const { uniqueVariables } = metadata
 
   if (!uniqueVariables || Object.keys(uniqueVariables).length === 0) {

package/types/src/capabilities.d.ts

@@ -0,0 +1,8 @@
+export const SCHEMA_VERSION: 1;
+export const VIEWS: string[];
+/**
+ * Build the capabilities contract object.
+ * @returns {object} stable, deterministic description of the CLI surface
+ */
+export function buildCapabilities(): object;
+//# sourceMappingURL=capabilities.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"capabilities.d.ts","sourceRoot":"","sources":["../../src/capabilities.js"],"names":[],"mappings":"AAOA,6BAAuB,CAAC,CAAA;AAExB,6BAAgD;AAEhD;;;GAGG;AACH,qCAFa,MAAM,CA2ClB"}

package/types/src/display.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Display "No Variables Found" message
+ * @param {string} configFilePath
+ * @param {RegExp} variableSyntax
+ * @param {Object} variableTypes
+ */
+export function displayNoVariablesFound(configFilePath: string, variableSyntax: RegExp, variableTypes: any): void;
+/**
+ * Display variable details in stacked box format
+ * @param {Object} params
+ * @param {string[]} params.varKeys
+ * @param {Object} params.variableData
+ * @param {Object} params.uniqueVariables
+ * @param {RegExp} params.varPrefixPattern
+ * @param {RegExp} params.varSuffixPattern
+ * @param {string[]} params.lines
+ * @param {string} params.fileType
+ * @param {string} params.configFilePath
+ */
+export function displayVariableDetails({ varKeys, variableData, uniqueVariables, varPrefixPattern, varSuffixPattern, lines, fileType, configFilePath }: {
+    varKeys: string[];
+    variableData: any;
+    uniqueVariables: any;
+    varPrefixPattern: RegExp;
+    varSuffixPattern: RegExp;
+    lines: string[];
+    fileType: string;
+    configFilePath: string;
+}): void;
+/**
+ * Display unique variables in stacked box format
+ * @param {Object} params
+ * @param {string[]} params.uniqueVarKeys
+ * @param {Object} params.uniqueVariables
+ * @param {string[]} params.lines
+ * @param {string} params.fileType
+ * @param {string} params.configFilePath
+ */
+export function displayUniqueVariables({ uniqueVarKeys, uniqueVariables, lines, fileType, configFilePath }: {
+    uniqueVarKeys: string[];
+    uniqueVariables: any;
+    lines: string[];
+    fileType: string;
+    configFilePath: string;
+}): void;
+/**
+ * Display configurable variables grouped by source type
+ * @param {Object} params
+ * @param {string[]} params.uniqueVarKeys
+ * @param {Object} params.uniqueVariables
+ * @param {string[]} params.lines
+ * @param {string} params.fileType
+ * @param {string} params.configFilePath
+ */
+export function displayConfigurableVariables({ uniqueVarKeys, uniqueVariables, lines, fileType, configFilePath }: {
+    uniqueVarKeys: string[];
+    uniqueVariables: any;
+    lines: string[];
+    fileType: string;
+    configFilePath: string;
+}): void;
+//# sourceMappingURL=display.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"display.d.ts","sourceRoot":"","sources":["../../src/display.js"],"names":[],"mappings":"AAiEA;;;;;GAKG;AACH,wDAJW,MAAM,kBACN,MAAM,4BAwBhB;AAED;;;;;;;;;;;GAWG;AACH,wJATG;IAAyB,OAAO,EAAxB,MAAM,EAAE;IACO,YAAY;IACZ,eAAe;IACf,gBAAgB,EAA/B,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACW,KAAK,EAAtB,MAAM,EAAE;IACO,QAAQ,EAAvB,MAAM;IACS,cAAc,EAA7B,MAAM;CAChB,QAiKA;AAED;;;;;;;;GAQG;AACH,4GANG;IAAyB,aAAa,EAA9B,MAAM,EAAE;IACO,eAAe;IACb,KAAK,EAAtB,MAAM,EAAE;IACO,QAAQ,EAAvB,MAAM;IACS,cAAc,EAA7B,MAAM;CAChB,QAmHA;AAED;;;;;;;;GAQG;AACH,kHANG;IAAyB,aAAa,EAA9B,MAAM,EAAE;IACO,eAAe;IACb,KAAK,EAAtB,MAAM,EAAE;IACO,QAAQ,EAAvB,MAAM;IACS,cAAc,EAA7B,MAAM;CAChB,QA2IA"}

package/types/src/errors.d.ts

@@ -0,0 +1,20 @@
+export const ERROR_CODES: {
+    code: string;
+    description: string;
+}[];
+export class ConfigoramaError extends Error {
+    constructor(code: any, message: any, details?: {});
+    code: any;
+    details: {};
+    toJSON(): {
+        error: {
+            code: any;
+            message: string;
+            details: {};
+        };
+    };
+}
+export function classifyErrorMessage(message: any, fallbackCode?: string): string;
+export function isConfigoramaError(error: any): boolean;
+export function normalizeError(error: any, fallbackCode?: string): any;
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.js"],"names":[],"mappings":"AAGA;;;IAmBC;AAED;IACE,mDAKC;IAFC,UAAuC;IACvC,YAAsB;IAGxB;;;;;;MAQC;CACF;AAgBD,kFAUC;AAxBD,wDAEC;AAED,uEAQC"}

package/types/src/index.d.ts

@@ -5,6 +5,99 @@ declare function _exports<T = any>(configPathOrObject: string | any, settings?:
 declare namespace _exports {
     export function sync<T = any>(configPathOrObject: string | any, settings?: ConfigoramaSettings): T;
     export function analyze(configPathOrObject: string | object, settings?: object): Promise<any>;
+    export function setup(configPathOrObject: string | any, settings?: object): Promise<object>;
+    export { writeDotenv };
+    export { writeAnswers };
+    export function introspect(configPathOrObject: any, settings?: {}): Promise<{
+        schemaVersion: number;
+        nodes: ({
+            id: string;
+            kind: string;
+            variable: any;
+            variableType: any;
+            sourceClass: any;
+            risk: string;
+            severity: string;
+            paths: any[];
+            sensitive: boolean;
+        } | {
+            id: string;
+            kind: string;
+            path: any;
+            relativePath: any;
+            exists: any;
+            risk: string;
+            severity: string;
+        })[];
+        edges: {
+            from: string;
+            to: string;
+            kind: string;
+        }[];
+        diagnostics: {
+            code: string;
+            severity: string;
+            variable: any;
+            message: string;
+        }[];
+        summary: {
+            nodes: number;
+            edges: number;
+            diagnostics: number;
+        };
+    }>;
+    export function audit(configPathOrObject: any, settings?: {}): Promise<{
+        schemaVersion: number;
+        safeMode: boolean;
+        findings: any[];
+        diagnostics: any;
+        summary: {
+            high: number;
+            medium: number;
+            low: number;
+            info: number;
+            total: number;
+        };
+    }>;
+    export function graph(configPathOrObject: any, settings?: {}): Promise<string | {
+        schemaVersion: number;
+        nodes: ({
+            id: string;
+            kind: string;
+            variable: any;
+            variableType: any;
+            sourceClass: any;
+            risk: string;
+            severity: string;
+            paths: any[];
+            sensitive: boolean;
+        } | {
+            id: string;
+            kind: string;
+            path: any;
+            relativePath: any;
+            exists: any;
+            risk: string;
+            severity: string;
+        })[];
+        edges: {
+            from: string;
+            to: string;
+            kind: string;
+        }[];
+        diagnostics: {
+            code: string;
+            severity: string;
+            variable: any;
+            message: string;
+        }[];
+        summary: {
+            nodes: number;
+            edges: number;
+            diagnostics: number;
+        };
+    }>;
+    export function inspect(configPathOrObject: string | object, settings?: object): Promise<object | string>;
     export { parsers as format };
     export { Configorama };
     export { buildVariableSyntax };
@@ -49,6 +142,18 @@ type ConfigoramaSettings = {
      * - allow undefined values to pass through without throwing errors
      */
     allowUndefinedValues?: boolean;
+    /**
+     * - glob-like config paths whose values should be left verbatim
+     */
+    ignorePaths?: string[];
+    /**
+     * - alias for ignorePaths
+     */
+    skipResolutionPaths?: string[];
+    /**
+     * - disable built-in CloudFormation and embedded-code ignore paths
+     */
+    disableDefaultIgnorePaths?: boolean;
     /**
      * - values passed into .js config files if user using javascript config
      */
@@ -57,6 +162,14 @@ type ConfigoramaSettings = {
      * - return both config and metadata about variables found
      */
     returnMetadata?: boolean;
+    /**
+     * - suppress env-stage-loader logs when useDotenv/useDotEnv is enabled
+     */
+    dotEnvSilent?: boolean;
+    /**
+     * - enable env-stage-loader debug logs when useDotenv/useDotEnv is enabled
+     */
+    dotEnvDebug?: boolean;
     /**
      * - keys to merge in arrays of objects
      */
@@ -67,6 +180,10 @@ type ConfigoramaSettings = {
     filePathOverrides?: {
         [x: string]: string;
     };
+    /**
+     * - install Configorama CLI signal handlers. Defaults to false for library calls.
+     */
+    handleSignalEvents?: boolean;
 };
 type ConfigoramaResult<T = any> = {
     /**
@@ -96,6 +213,8 @@ type ConfigoramaResult<T = any> = {
      */
     resolutionHistory: any;
 };
+import { writeDotenv } from "./utils/setup/writeDotenv";
+import { writeAnswers } from "./utils/setup/writeAnswers";
 import parsers = require("./parsers");
 import Configorama = require("./main");
 import { buildVariableSyntax } from "./utils/variables/variableUtils";

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":";;;AAuCiB,0BALH,CAAC,4BACJ,MAAM,MAAO,aACb,mBAAmB,GACjB,OAAO,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAiD7C;;IASqB,qBALR,CAAC,4BACJ,MAAM,MAAO,aACb,mBAAmB,GACjB,CAAC,CAgBb;IAQwB,4CAJb,MAAM,GAAC,MAAM,aACd,MAAM,gBAUhB;;;;;;;;;;;;;;;;aApHa,MAAM;;;;gBACN,MAAM;;;;;;;;;;;;;;;;;;;;uBAIN,OAAO;;;;2BACP,OAAO;;;;kBACP,cAAe;;;;qBACf,OAAO;;;;gBACP,MAAM,EAAE;;;;;;;;uBAKR,CAAC;;;;oBAED,MAAM;;;;;;;;;;YAEN,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":";;;AAwDiB,0BALH,CAAC,4BACJ,MAAM,MAAO,aACb,mBAAmB,GACjB,OAAO,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAiD7C;;IASqB,qBALR,CAAC,4BACJ,MAAM,MAAO,aACb,mBAAmB,GACjB,CAAC,CAgBb;IAQwB,4CAJb,MAAM,GAAC,MAAM,aACd,MAAM,gBAchB;IAQsB,0CAJZ,MAAM,MAAO,aACb,MAAM,GACL,OAAO,CAAC,MAAM,CAAC,CAI1B;;;IAQ2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAS3B;IAEsB;;;;;;;;;;;;OAyBtB;IAEsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAItB;IAUwB,4CAJd,MAAM,GAAC,MAAM,aACb,MAAM,GACL,OAAO,CAAC,MAAM,GAAC,MAAM,CAAC,CAiCjC;;;;;;;;;;;;;;;;aAnOa,MAAM;;;;gBACN,MAAM;;;;;;;;;;;;;;;;;;;;uBAIN,OAAO;;;;2BACP,OAAO;;;;kBACP,MAAM,EAAE;;;;0BACR,MAAM,EAAE;;;;gCACR,OAAO;;;;kBACP,cAAe;;;;qBACf,OAAO;;;;mBACP,OAAO;;;;kBACP,OAAO;;;;gBACP,MAAM,EAAE;;;;;;;;;;yBAER,OAAO;;uBAIP,CAAC;;;;oBAED,MAAM;;;;;;;;;;YAEN,CAAC"}