@stacksjs/dtsx 0.6.1 → 0.6.2

package/dist/extract.d.ts

@@ -7,1313 +7,62 @@ export declare function extractDtsTypes(sourceCode: string): string;
 declare function extractFunctionSignature(declaration: string): FunctionSignature;
 declare function extractFunctionName(declaration: string): string;
 declare function extractGenerics(rest: string);
-function extractParams(rest: string): { params: string, rest: string } {
-  let params = ''
-  if (rest.includes('(')) {
-    const start = rest.indexOf('(')
-    let depth = 1
-    let pos = start + 1
-    let buffer = ''
-
-    debugLog('params-extraction-start', `Starting params extraction from pos ${pos}: ${rest}`)
-
-    for (; pos < rest.length; pos++) {
-      const char = rest[pos]
-
-      if (char === '(')
-        depth++
-      if (char === ')') {
-        depth--
-        if (depth === 0) {
-          debugLog('params-depth-zero', `Found closing parenthesis at pos ${pos}`)
-          break
-        }
-      }
-
-      buffer += char
-    }
-
-    params = buffer.trim()
-    rest = rest.slice(pos + 1).trim()
-    debugLog('signature-params', `Extracted params: ${params}`)
-  }
-  return { params, rest }
-}
-
-function extractReturnType(rest: string): { returnType: string } {
-  let returnType = 'void'
-  if (rest.startsWith(':')) {
-    debugLog('return-start', `Starting return type extraction with: ${rest}`)
-    rest = rest.slice(1).trim()
-
-    let depth = 0
-    let buffer = ''
-    let i = 0
-    let inString = false
-    let stringChar = ''
-    let foundEnd = false
-
-    debugLog('return-extraction', 'Starting character-by-character extraction')
-
-    while (i < rest.length && !foundEnd) {
-      const char = rest[i]
-      const prevChar = i > 0 ? rest[i - 1] : ''
-
-      debugLog('return-char', `Pos ${i}: Char "${char}", Depth ${depth}, InString ${inString}, Buffer length ${buffer.length}`)
-
-      if ((char === '"' || char === '\'' || char === '`') && prevChar !== '\\') {
-        if (!inString) {
-          inString = true
-          stringChar = char
-          debugLog('return-string', `Entering string with ${stringChar}`)
-        }
-        else if (char === stringChar) {
-          inString = false
-          debugLog('return-string', 'Exiting string')
-        }
-      }
-
-      if (!inString) {
-        if (char === '{' || char === '<' || char === '(') {
-          depth++
-          debugLog('return-depth', `Opening bracket, increasing depth to ${depth}`)
-        }
-        else if (char === '}' || char === '>' || char === ')') {
-          depth--
-          debugLog('return-depth', `Closing bracket, decreasing depth to ${depth}`)
-
-          if (depth === 0 && char === '}') {
-            buffer += char
-            const nextNonWhitespace = rest.slice(i + 1).trim()[0]
-            if (nextNonWhitespace === '{') {
-              debugLog('return-end', `Found end of return type at pos ${i}, next char is function body`)
-              foundEnd = true
-              break
-            }
-          }
-        }
-
-        if (depth === 0 && char === ';') {
-          debugLog('return-end', 'Found semicolon at depth 0')
-          foundEnd = true
-          break
-        }
-      }
-
-      buffer += char
-      debugLog('return-buffer', `Updated buffer: ${buffer}`)
-      i++
-    }
-
-    returnType = buffer.trim()
-    debugLog('return-final', `Final extracted return type: ${returnType}`)
-  }
-  return { returnType }
-}
-
-function extractFunctionType(value: string): string | null {
-  debugLog('extract-function', `Extracting function type from: ${value}`)
-
-  const cleanValue = value.trim()
-  let pos = 0
-  const length = cleanValue.length
-
-  if (!cleanValue.startsWith('(')) {
-    const funcMatch = cleanValue.match(/^function\s*\w*\s*\((.*?)\)/s)
-    if (funcMatch) {
-      const [, params] = funcMatch
-      const cleanParams = cleanParameterTypes(params || '')
-      const returnTypeMatch = cleanValue.match(/\):\s*([^{;]+)(?:[{;]|$)/)
-      const returnType = returnTypeMatch ? normalizeType(returnTypeMatch[1]) : 'unknown'
-      return `(${cleanParams}) => ${returnType}`
-    }
-    return null
-  }
-
-  pos++ 
-  let depth = 1
-  const paramsStart = pos
-  let inString = false
-  let stringChar = ''
-  for (; pos < length; pos++) {
-    const char = cleanValue[pos]
-    const prevChar = pos > 0 ? cleanValue[pos - 1] : ''
-
-    if (inString) {
-      if (char === stringChar && prevChar !== '\\') {
-        inString = false
-      }
-      else if (char === '\\') {
-        pos++ 
-      }
-    }
-    else {
-      if (char === '"' || char === '\'' || char === '`') {
-        inString = true
-        stringChar = char
-      }
-      else if (char === '(') {
-        depth++
-      }
-      else if (char === ')') {
-        depth--
-        if (depth === 0) {
-          break
-        }
-      }
-    }
-  }
-  if (depth !== 0) {
-    debugLog('extract-function', 'Unbalanced parentheses in function parameters')
-    return null
-  }
-
-  const paramsEnd = pos
-  const params = cleanValue.slice(paramsStart, paramsEnd)
-
-  pos++ 
-
-  while (pos < length && /\s/.test(cleanValue[pos])) pos++
-
-  let returnType = 'unknown'
-  if (cleanValue[pos] === ':') {
-    pos++ 
-    while (pos < length && /\s/.test(cleanValue[pos])) pos++
-    const returnTypeStart = pos
-    while (pos < length && !cleanValue.startsWith('=>', pos) && cleanValue[pos] !== '{') {
-      pos++
-    }
-    const returnTypeEnd = pos
-    returnType = cleanValue.slice(returnTypeStart, returnTypeEnd).trim()
-  }
-
-  while (pos < length && /\s/.test(cleanValue[pos])) pos++
-
-  if (cleanValue.startsWith('=>', pos)) {
-    pos += 2
-  }
-  else {
-    debugLog('extract-function', 'Function expression missing "=>"')
-    return null
-  }
-
-  const cleanParams = cleanParameterTypes(params || '')
-  debugLog('extract-function', `Extracted function type: (${cleanParams}) => ${returnType}`)
-  return `(${cleanParams}) => ${returnType}`
-}
-
-function generateOptimizedImports(state: ImportTrackingState): string[] {
-  const imports: string[] = []
-  const seenImports = new Set<string>()
-
-  debugLog('import-gen', `Generating optimized imports. ${state.exportedTypes.size} exported types`)
-
-  for (const [module, types] of state.typeImports) {
-    debugLog('import-type-check', `Checking types from ${module}: ${Array.from(types).join(', ')}`)
-    const typeImports = Array.from(types)
-      .filter((t) => {
-        const isUsed = state.exportedTypes.has(t) || state.usedTypes.has(t)
-        debugLog('import-type-filter', `Type ${t}: exported=${state.exportedTypes.has(t)}, used=${state.usedTypes.has(t)}`)
-        return isUsed
-      })
-      .map((t) => {
-        const alias = state.valueAliases.get(t)
-        return alias ? `${t} as ${alias}` : t
-      })
-      .sort()
-
-    if (typeImports.length > 0) {
-      const importStatement = `import type { ${typeImports.join(', ')} } from '${module}'`
-      if (!seenImports.has(importStatement)) {
-        imports.push(importStatement)
-        seenImports.add(importStatement)
-        debugLog('import-add-type', `Added type import: ${importStatement}`)
-      }
-    }
-  }
-
-  for (const [module, values] of state.valueImports) {
-    const moduleAliases = new Map<string, string>()
-    const valueImports = Array.from(values)
-      .filter((v) => {
-        const alias = Array.from(state.valueAliases.entries())
-          .find(([_, orig]) => orig === v)?.[0]
-        const isUsed = state.exportedValues.has(v)
-          || state.usedValues.has(v)
-          || v === state.defaultExportValue
-          || (alias && (state.exportedValues.has(alias) || alias === state.defaultExportValue))
-
-        if (isUsed && alias) {
-          moduleAliases.set(v, alias)
-        }
-        return isUsed
-      })
-      .map((v) => {
-        const alias = moduleAliases.get(v)
-        return alias ? `${v} as ${alias}` : v
-      })
-      .sort()
-
-    if (valueImports.length > 0) {
-      const importStatement = `import { ${valueImports.join(', ')} } from '${module}'`
-      if (!seenImports.has(importStatement)) {
-        imports.push(importStatement)
-        seenImports.add(importStatement)
-        debugLog('import-add-value', `Added value import: ${importStatement}`)
-      }
-    }
-  }
-
-  return imports.sort()
-}
-
-function extractCompleteObjectContent(value: string): string | null {
-  const fullContent = value.trim()
-
-  if (!fullContent.startsWith('{')) {
-    return null
-  }
-
-  let depth = 0
-  let inString = false
-  let stringChar = ''
-
-  for (let i = 0; i < fullContent.length; i++) {
-    const char = fullContent[i]
-    const prevChar = i > 0 ? fullContent[i - 1] : ''
-
-    if ((char === '"' || char === '\'' || char === '`') && prevChar !== '\\') {
-      if (!inString) {
-        inString = true
-        stringChar = char
-      }
-      else if (char === stringChar) {
-        inString = false
-      }
-      continue
-    }
-
-    if (!inString) {
-      if (char === '{') {
-        depth++
-      }
-      else if (char === '}') {
-        depth--
-        if (depth === 0) {
-          return fullContent.slice(0, i + 1)
-        }
-      }
-    }
-  }
-
-  return null
-}
-
-function formatOutput(state: ProcessingState): string {
-  const imports = new Set<string>()
-
-  state.dtsLines
-    .filter(line => line.startsWith('import'))
-    .forEach(imp => imports.add(imp.replace(/;+$/, '')))
-
-  const declarations = state.dtsLines
-    .filter(line => !line.startsWith('import'))
-    .map((line) => {
-      if (line.trim().startsWith('g, '')) 
-    .filter(line => line.trim() || line === '') 
-    .join('\n')
-    .trim()
-}
-
-function removeLeadingComments(code: string): string {
-  const lines = code.split('\n')
-  let index = 0
-  while (index < lines.length) {
-    const line = lines[index].trim()
-    if (line.startsWith('
-      index++
-    }
-    else {
-      break
-    }
-  }
-  return lines.slice(index).join('\n')
-}
-
-function createProcessingState(): ProcessingState {
-  return {
-    dtsLines: [],
-    imports: [],
-    usedTypes: new Set(),
-    typeSources: new Map(),
-    defaultExport: null,
-    exportAllStatements: [],
-    currentDeclaration: '',
-    lastCommentBlock: '',
-    bracketCount: 0,
-    isMultiLineDeclaration: false,
-    moduleImports: new Map(),
-    availableTypes: new Map(),
-    availableValues: new Map(),
-    currentIndentation: '',
-    declarationBuffer: null,
-    importTracking: createImportTrackingState(),
-    defaultExports: new Set(),
-    currentScope: 'top',
-  }
-}
-
-function createImportTrackingState(): ImportTrackingState {
-  return {
-    typeImports: new Map(),
-    valueImports: new Map(),
-    usedTypes: new Set(),
-    usedValues: new Set(),
-    exportedTypes: new Set(),
-    exportedValues: new Set(),
-    valueAliases: new Map(),
-    importSources: new Map(),
-    typeExportSources: new Map(),
-    defaultExportValue: undefined,
-  }
-}
-
-function indentMultilineType(type: string, baseIndent: string, isLast: boolean): string {
-  const lines = type.split('\n')
-  if (lines.length === 1)
-    return `${baseIndent}${type}${isLast ? '' : ' |'}`
-
-  interface BracketInfo {
-    char: string
-    indent: string
-    isArray: boolean
-    depth: number
-    isSingleElement?: boolean
-  }
-  const bracketStack: BracketInfo[] = []
-
-  let isInSingleElementArray = false
-  let arrayElementCount = 0
-  lines.forEach((line) => {
-    const trimmed = line.trim()
-    if (trimmed.startsWith('Array<')) {
-      arrayElementCount = 0
-    }
-    if (trimmed === '}' || trimmed.startsWith('> |') || trimmed === '>') {
-      isInSingleElementArray = arrayElementCount === 1
-    }
-    if (trimmed && !trimmed.startsWith('Array<') && !trimmed.endsWith('>') && !trimmed.startsWith('{') && !trimmed.endsWith('}')) {
-      arrayElementCount++
-    }
-  })
-
-  const formattedLines = lines.map((line, i) => {
-    const trimmed = line.trim()
-    if (!trimmed)
-      return ''
-
-    let currentIndent = baseIndent
-    if (i > 0) {
-      const stackDepth = bracketStack.reduce((depth, info) => depth + info.depth, 0)
-      currentIndent = baseIndent + '  '.repeat(stackDepth)
-
-      if (trimmed.match(/^['"]/)) { 
-        currentIndent += '  '
-      }
-
-      if ((trimmed.startsWith('}') || trimmed.startsWith('>') || trimmed.startsWith('> |')) && bracketStack.length > 0) {
-        currentIndent = baseIndent + '  '.repeat(Math.max(0, stackDepth - 1))
-      }
-    }
-
-    const openBrackets = trimmed.match(/[{<[]/g) || []
-    const closeBrackets = trimmed.match(/[}\]>]/g) || []
-
-    openBrackets.forEach((bracket) => {
-      const isArrayBracket = trimmed.startsWith('Array') && bracket === '<'
-      bracketStack.push({
-        char: bracket,
-        indent: currentIndent,
-        isArray: isArrayBracket,
-        depth: 1,
-        isSingleElement: isInSingleElementArray,
-      })
-    })
-
-    if (closeBrackets.length > 0) {
-      for (let j = 0; j < closeBrackets.length; j++) {
-        if (bracketStack.length > 0)
-          bracketStack.pop()
-      }
-    }
-
-    let needsUnion = false
-    if (!isLast && i === lines.length - 1 && !trimmed.endsWith(' |') && !trimmed.endsWith(';')) {
-      needsUnion = true
-    }
-
-    if (trimmed === '}') {
-      const lastArray = [...bracketStack].reverse().find(info => info.isArray)
-      if (lastArray?.isSingleElement)
-        needsUnion = false
-    }
-
-    if (trimmed.endsWith(' |'))
-      needsUnion = false
-
-    return `${currentIndent}${trimmed}${needsUnion ? ' |' : ''}`
-  }).filter(Boolean)
-
-  return formattedLines.join('\n')
-}
-
-function inferValueType(value: string): string {
-  const normalizedValue = value.split('\n').map(line => line.trim()).join(' ')
-
-  if (/^['"`].*['"`]$/.test(normalizedValue)) {
-    return normalizedValue
-  }
-
-  if (!Number.isNaN(Number(normalizedValue))) {
-    return normalizedValue
-  }
-
-  if (normalizedValue === 'true' || normalizedValue === 'false') {
-    return normalizedValue
-  }
-
-  const returnTypeMatch = normalizedValue.match(/\([^)]*\)\s*:\s*([^=>{]+)/)
-  if (returnTypeMatch) {
-    return returnTypeMatch[1].trim()
-  }
-
-  if (normalizedValue.includes('=>')) {
-    return '(...args: any[]) => unknown'
-  }
-
-  return 'unknown'
-}
-
-function inferArrayType(value: string, state?: ProcessingState, preserveLineBreaks = false): string {
-  const content = value.slice(1, -1).trim()
-  const isConstAssertion = value.trim().endsWith('as const')
-
-  if (!content)
-    return isConstAssertion ? 'readonly unknown[]' : 'unknown[]'
-
-  const elements = splitArrayElements(content)
-
-  if (isConstAssertion || elements.some(el => el.includes('as const'))) {
-    const tuples = elements.map((el) => {
-      const cleaned = el.trim().replace(/\s*as\s*const\s*$/, '').trim()
-      return inferConstArrayType(cleaned, state)
-    })
-
-    if (needsMultilineFormat(tuples)) {
-      const formattedContent = tuples.map((type, i) =>
-        indentMultilineType(type, '    ', i === tuples.length - 1),
-      ).join('\n')
-      return `readonly [\n${formattedContent}\n  ]`
-    }
-
-    return `readonly [${tuples.join(', ')}]`
-  }
-
-  const elementTypes = elements.map((element) => {
-    const trimmed = element.trim()
-    if (trimmed.startsWith('[')) {
-      return inferArrayType(trimmed, state)
-    }
-    else if (trimmed.startsWith('{')) {
-      return inferComplexObjectType(trimmed, state)
-    }
-    else if (trimmed.includes('=>') || trimmed.includes('function')) {
-      const funcType = extractFunctionType(trimmed)
-      return funcType ? `(${funcType})` : '((...args: any[]) => unknown)'
-    }
-    else {
-      return normalizeTypeReference(trimmed)
-    }
-  })
-
-  const types = elementTypes.filter(Boolean)
-  const needsMultiline = types.some(type =>
-    type.includes('\n')
-    || type.includes('{')
-    || type.length > 40
-    || types.join(' | ').length > 60,
-  )
-
-  if (needsMultiline && preserveLineBreaks) {
-    const formattedContent = types.map((type, i) =>
-      indentMultilineType(type, '    ', i === types.length - 1),
-    ).join('\n')
-    return `Array<\n${formattedContent}\n  >`
-  }
-
-  return `Array<${types.join(' | ')}>`
-}
-
-function inferComplexObjectType(value: string, state?: ProcessingState, indentLevel = 0): string {
-  const content = extractCompleteObjectContent(value)
-  if (!content)
-    return 'Record<string, unknown>'
-
-  const baseIndent = '  '.repeat(indentLevel)
-  const propIndent = '  '.repeat(indentLevel + 1)
-  const closingIndent = baseIndent 
-
-  const props = processObjectProperties(content, state, indentLevel)
-  if (!props.length)
-    return '{}'
-
-  const propertyStrings = props.map(({ key, value }) => {
-    return `${propIndent}${key}: ${value}`
-  })
-
-  return `{\n${propertyStrings.join(';\n')}\n${closingIndent}}`
-}
-
-function inferConstArrayType(value: string, state?: ProcessingState): string {
-
-  if (/^['"`].*['"`]$/.test(value)) {
-    const cleaned = value
-      .replace(/\]\s*as\s*cons.*$/, '')
-      .replace(/^['"`]|['"`]$/g, '')
-    return `'${cleaned}'`
-  }
-
-  if (value.startsWith('[')) {
-    const content = value.slice(1, -1).trim()
-    const elements = splitArrayElements(content)
-
-    const literalTypes = elements.map((element) => {
-      let trimmed = element.trim()
-
-      if (trimmed.includes('] as cons') || trimmed.includes('] as const')) {
-        trimmed = trimmed
-          .replace(/\]\s*as\s*cons.*$/, '')
-          .replace(/\]\s*as\s*const.*$/, '')
-          .trim()
-      }
-
-      if (trimmed.startsWith('[')) {
-        return inferConstArrayType(trimmed, state)
-      }
-
-      if (trimmed.startsWith('{')) {
-        const result = inferComplexObjectType(trimmed, state)
-        return result.replace(/^\{/, '{ readonly').replace(/;\s+/g, '; readonly ')
-      }
-
-      if (/^['"`].*['"`]$/.test(trimmed)) {
-        const stringContent = trimmed.replace(/^['"`]|['"`]$/g, '')
-        return `'${stringContent}'`
-      }
-
-      if (!Number.isNaN(Number(trimmed))) {
-        return trimmed
-      }
-
-      if (trimmed === 'true' || trimmed === 'false') {
-        return trimmed
-      }
-
-      const cleanString = trimmed
-        .replace(/\]\s*as\s*cons.*$/, '') 
-        .replace(/\]\s*as\s*const.*$/, '') 
-        .replace(/^['"`]|['"`]$/g, '') 
-        .trim()
-
-      return `'${cleanString}'`
-    })
-
-    return `readonly [${literalTypes.join(', ')}]`
-  }
-
-  const cleanString = value
-    .replace(/\]\s*as\s*cons.*$/, '')
-    .replace(/\]\s*as\s*const.*$/, '')
-    .replace(/^['"`]|['"`]$/g, '')
-    .trim()
-
-  return `'${cleanString}'`
-}
-
-function inferConstType(value: string, state: ProcessingState): string {
-  if (value.startsWith('{')) {
-    return inferComplexObjectType(value, state)
-  }
-  if (value.startsWith('[')) {
-    return inferArrayType(value, state,  true)
-  }
-  return value
-}
-
-function inferTypeFromDefaultValue(defaultValue: string): string {
-  if (/^['"`].*['"`]$/.test(defaultValue)) {
-    return 'string'
-  }
-
-  if (!Number.isNaN(Number(defaultValue))) {
-    return 'number'
-  }
-
-  if (defaultValue === 'true' || defaultValue === 'false') {
-    return 'boolean'
-  }
-
-  if (defaultValue.startsWith('[')) {
-    return 'unknown[]'
-  }
-
-  if (defaultValue.startsWith('{')) {
-    return 'object'
-  }
-
-  if (defaultValue === 'null')
-    return 'null'
-  if (defaultValue === 'undefined')
-    return 'undefined'
-
-  return 'unknown'
-}
-
-
-function isDefaultExport(line: string): boolean {
-  return line.trim().startsWith('export default')
-}
-
-function isDeclarationStart(line: string): boolean {
-  if (isRegexPattern(line))
-    return false
-
-  const trimmed = line.trim()
-
-  if (/^(?:export\s+)?(?:async\s+)?function\s*\*?\s*[a-zA-Z_$][\w$]*/.test(trimmed))
-    return true
-
-  return (
-    trimmed.startsWith('export ')
-    || trimmed.startsWith('interface ')
-    || trimmed.startsWith('type ')
-    || trimmed.startsWith('const ')
-    || trimmed.startsWith('function ')
-    || trimmed.startsWith('async function ')
-    || trimmed.startsWith('declare ')
-    || trimmed.startsWith('declare module')
-    || /^export\s+(?:interface|type|const|function\*?|async\s+function\*?)/.test(trimmed)
-  )
-}
-
-function isRegexPattern(line: string): boolean {
-  return (
-    line.includes('\\')
-    || line.includes('[^')
-    || line.includes('(?:')
-    || line.includes('(?=')
-    || line.includes('(?!')
-    || line.includes('\\s*')
-    || line.includes('\\w+')
-    || line.includes('\\d+')
-    || line.includes('(?<')
-    || line.includes('(?!')
-    || line.includes('(?<=')
-    || line.includes('(?<!')
-  )
-}
-
-export function isFunctionType(type: string): boolean {
-  const functionTypeRegex = /^\s*\(.*\)\s*=>\s*(?:\S.*|[\t\v\f \xA0\u1680\u2000-\u200A\u202F\u205F\u3000\uFEFF])$/
-  return functionTypeRegex.test(type.trim())
-}
-
-export function isDeclarationComplete(content: string | string[]): boolean {
-  const fullContent = Array.isArray(content) ? content.join('\n') : content
-  const trimmedContent = fullContent.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, '').trim()
-  return /;\s*$/.test(trimmedContent) || /\}\s*$/.test(trimmedContent)
-}
-
-function isVariableInsideFunction(line: string, state: ProcessingState): boolean {
-  const trimmed = line.trim()
-  return (
-    state.currentScope === 'function'
-    && (trimmed.startsWith('const ')
-      || trimmed.startsWith('let ')
-      || trimmed.startsWith('var ')
-      || /^(?:const|let|var)\s+[a-zA-Z_$][\w$]*\s*(?::|=)/.test(trimmed))
-  )
-}
-
-function needsMultilineFormat(types: string[]): boolean {
-  return types.some(type =>
-    type.includes('\n')
-    || type.includes('{')
-    || type.length > 40
-    || types.join(' | ').length > 60,
-  )
-}
-
-function normalizeTypeReference(value: string): string {
-  if (value.includes('=>') || value.match(/\bfunction\b/)) {
-    return '((...args: any[]) => unknown)'
-  }
-
-  if (value.match(/\w+\s*\([^)]*\)/)) {
-    return 'unknown'
-  }
-
-  if (value.startsWith('new ')) {
-    return 'unknown'
-  }
-
-  if (value.includes('.')) {
-    return 'unknown'
-  }
-
-  if (/^[a-z_$][\w$]*$/i.test(value)
-    && !['unknown', 'string', 'number', 'boolean', 'null', 'undefined', 'any', 'never', 'void'].includes(value)
-    && !/^['"`]|^\d/.test(value)
-    && value !== 'true'
-    && value !== 'false') {
-    return 'unknown'
-  }
-
-  return value
-}
-
-function processBlock(lines: string[], comments: string[], state: ProcessingState): void {
-  debugLog('block-processing', 'Starting block processing')
-
-  const cleanedLines = lines.filter((line) => {
-    const trimmed = line.trim()
-    return !trimmed.startsWith('.test(cleanDeclaration)) {
-    debugLog('block-processing', 'Processing generator function declaration')
-    const processed = processGeneratorFunction(cleanDeclaration)
-    if (processed) {
-      state.dtsLines.push(processed)
-      return true
-    }
-  }
-
-  if (!/^(?:export\s+)?(?:async\s+)?function\s+[a-zA-Z_$][\w$]*/.test(cleanDeclaration))
-    return false
-
-  debugLog('block-processing', 'Processing function declaration')
-
-  const declarations = cleanDeclaration
-    .split(/[\n;]/)
-    .map(d => d.trim())
-    .filter(d => d.startsWith('export function') || d.startsWith('function'))
-
-  if (declarations.length > 1) {
-    declarations.forEach((declaration) => {
-      if (!declaration.endsWith('{')) { 
-        const processed = processFunction(declaration, state.usedTypes, declaration.startsWith('export'))
-        if (processed)
-          state.dtsLines.push(processed)
-      }
-    })
-    return true
-  }
-
-  let signatureEnd = 0
-  let parenDepth = 0
-  let angleDepth = 0
-
-  for (let i = 0; i < cleanDeclaration.length; i++) {
-    const char = cleanDeclaration[i]
-
-    if (char === '(')
-      parenDepth++
-    if (char === ')')
-      parenDepth--
-
-    if (char === '<')
-      angleDepth++
-    if (char === '>')
-      angleDepth--
-
-    if (char === '{') {
-      if (parenDepth === 0 && angleDepth === 0) {
-        signatureEnd = i
-        break
-      }
-    }
-  }
-
-  if (signatureEnd === 0)
-    signatureEnd = cleanDeclaration.length
-
-  const signaturePart = cleanDeclaration.slice(0, signatureEnd).trim()
-
-  debugLog('signature-extraction', `Extracted signature: ${signaturePart}`)
-
-  const isExported = signaturePart.startsWith('export')
-  const processed = processFunction(signaturePart, state.usedTypes, isExported)
-  if (processed) {
-    debugLog('function-processed', `Generated declaration: ${processed}`)
-    state.dtsLines.push(processed)
-  }
-
-  return true
-}
-
-function processInterfaceBlock(cleanDeclaration: string, declarationText: string, state: ProcessingState): boolean {
-  debugLog('interface-processing', `Starting interface processing with declaration: ${cleanDeclaration.slice(0, 100)}...`)
-
-  if (!cleanDeclaration.startsWith('interface') && !cleanDeclaration.startsWith('export interface')) {
-    debugLog('interface-processing', 'Not an interface declaration, skipping')
-    return false
-  }
-
-  const lines = declarationText.split('\n')
-  let bracketDepth = 0
-  let angleDepth = 0
-  const processedLines: string[] = []
-  let isFirstLine = true
-  let hasStartedBody = false
-
-  debugLog('interface-processing', `Processing ${lines.length} lines`)
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]
-    const trimmedLine = line.trim()
-
-    const openCurly = (line.match(/\{/g) || []).length
-    const closeCurly = (line.match(/\}/g) || []).length
-    const openAngle = (line.match(/</g) || []).length
-    const closeAngle = (line.match(/>/g) || []).length
-
-    bracketDepth += openCurly - closeCurly
-    angleDepth += openAngle - closeAngle
-
-    if (trimmedLine.includes('{')) {
-      hasStartedBody = true
-    }
-
-    debugLog('interface-depth', `Line ${i + 1}: "${trimmedLine}" `
-    + `Bracket depth: ${bracketDepth}, Angle depth: ${angleDepth}, `
-    + `Has started body: ${hasStartedBody}`)
-
-    if (isFirstLine) {
-      const prefix = trimmedLine.startsWith('export') ? 'export declare' : 'declare'
-      processedLines.push(
-        line.replace(
-          /^(\s*)(?:export\s+)?interface/,
-          `$1${prefix} interface`,
-        ),
-      )
-      isFirstLine = false
-    }
-    else {
-      processedLines.push(line)
-    }
-  }
-
-  const result = processedLines.join('\n')
-  const hasCompleteBody = result.includes('{') && result.includes('}')
-  const isComplete = (bracketDepth === 0 && (angleDepth === 0 || result.includes('>'))) && hasCompleteBody
-
-  if (isComplete) {
-    debugLog('interface-processing', `Successfully processed interface:\n${result}`)
-    state.dtsLines.push(result)
-    return true
-  }
-
-  debugLog('interface-processing', `Interface processing incomplete. Bracket depth: ${bracketDepth}, `
-  + `Angle depth: ${angleDepth}, Has started body: ${hasStartedBody}`)
-  return false
-}
-
-function processTypeBlock(cleanDeclaration: string, declarationText: string, state: ProcessingState): boolean {
-  if (!cleanDeclaration.startsWith('type') && !cleanDeclaration.startsWith('export type'))
-    return false
-
-  const isExported = cleanDeclaration.startsWith('export')
-  state.dtsLines.push(processType(declarationText, isExported))
-  return true
-}
-
-function processDefaultExportBlock(cleanDeclaration: string, state: ProcessingState): boolean {
-  if (!isDefaultExport(cleanDeclaration))
-    return false
-
-  const exportedValue = cleanDeclaration.replace(/^export\s+default\s+/, '').replace(/;$/, '')
-  state.importTracking.defaultExportValue = exportedValue
-
-  const defaultExport = cleanDeclaration.endsWith(';')
-    ? cleanDeclaration
-    : `${cleanDeclaration};`
-
-  state.defaultExports.add(defaultExport)
-  return true
-}
-
-function processExportAllBlock(cleanDeclaration: string, state: ProcessingState): boolean {
-  if (!cleanDeclaration.startsWith('export *'))
-    return false
-
-  state.exportAllStatements.push(cleanDeclaration)
-  state.dtsLines.push(cleanDeclaration)
-  return true
-}
-
-function processExportBlock(cleanDeclaration: string, declarationText: string, state: ProcessingState): boolean {
-  if (!cleanDeclaration.startsWith('export'))
-    return false
-
-  if (processExportedClass(cleanDeclaration, state))
-    return true
-  if (processExportedEnum(cleanDeclaration, state))
-    return true
-  if (processExportedNamespace(cleanDeclaration, state))
-    return true
-
-  if (cleanDeclaration.startsWith('export {')) {
-    state.dtsLines.push(declarationText)
-    return true
-  }
-
-  debugLog('processing', `Unhandled exported declaration type: ${cleanDeclaration.split('\n')[0]}`)
-  return true
-}
-
-function processExport(line: string, state: ProcessingState): void {
-  debugLog('export-processing', `Processing export: ${line}`)
-
-  const exportMatch = line.match(/export\s*\{([^}]+)\}(?:\s*from\s*['"]([^'"]+)['"])?/)
-  if (!exportMatch) {
-    debugLog('export-error', 'Failed to match export pattern')
-    return
-  }
-
-  const [, exports, sourceModule] = exportMatch
-  debugLog('export-found', `Found exports: ${exports}, source: ${sourceModule || 'local'}`)
-
-  exports.split(',').forEach((exp) => {
-    const [itemName, aliasName] = exp.trim().split(/\s+as\s+/).map(e => e.trim())
-
-    if (itemName.startsWith('type ')) {
-      const typeName = itemName.replace(/^type\s+/, '').trim()
-      const exportedName = aliasName || typeName
-      state.importTracking.exportedTypes.add(exportedName)
-      if (sourceModule) {
-        state.importTracking.typeExportSources.set(exportedName, sourceModule)
-      }
-      debugLog('export-type-processed', `Added exported type: ${exportedName}`)
-    }
-    else {
-      const exportedName = aliasName || itemName
-      state.importTracking.exportedValues.add(exportedName)
-      debugLog('export-value-processed', `Added exported value: ${exportedName}`)
-    }
-  })
-}
-
-function processExportedClass(cleanDeclaration: string, state: ProcessingState): boolean {
-  if (!cleanDeclaration.startsWith('export class')
-    && !cleanDeclaration.startsWith('export abstract class')) {
-    return false
-  }
-
-  const processed = `export declare ${cleanDeclaration.replace(/^export\s+/, '')}`
-  state.dtsLines.push(processed)
-  return true
-}
-
-function processExportedEnum(cleanDeclaration: string, state: ProcessingState): boolean {
-  if (!cleanDeclaration.startsWith('export enum')
-    && !cleanDeclaration.startsWith('export const enum')) {
-    return false
-  }
-
-  const processed = `export declare ${cleanDeclaration.replace(/^export\s+/, '')}`
-  state.dtsLines.push(processed)
-  return true
-}
-
-function processExportedNamespace(cleanDeclaration: string, state: ProcessingState): boolean {
-  if (!cleanDeclaration.startsWith('export namespace'))
-    return false
-
-  const processed = `export declare ${cleanDeclaration.replace(/^export\s+/, '')}`
-  state.dtsLines.push(processed)
-  return true
-}
-
-function processModuleBlock(cleanDeclaration: string, declarationText: string, state: ProcessingState): boolean {
-  if (!cleanDeclaration.startsWith('declare module'))
-    return false
-
-  const processed = processModule(declarationText)
-  state.dtsLines.push(processed)
-  return true
-}
-
-export function processSpecificDeclaration(declarationWithoutComments: string, fullDeclaration: string, state: ProcessingState): void {
-
-  if (isDefaultExport(declarationWithoutComments)) {
-
-    const defaultExport = declarationWithoutComments.endsWith(';')
-      ? declarationWithoutComments
-      : `${declarationWithoutComments};`
-
-    state.defaultExports.add(defaultExport)
-    return
-  }
-
-  if (declarationWithoutComments.startsWith('declare module')) {
-    const processed = processModule(fullDeclaration)
-    state.dtsLines.push(processed)
-    return
-  }
-
-  if (
-    declarationWithoutComments.startsWith('export const')
-    || declarationWithoutComments.startsWith('const')
-  ) {
-    const isExported = declarationWithoutComments.trimStart().startsWith('export')
-    const processed = processVariable(fullDeclaration, isExported, state)
-    state.dtsLines.push(processed)
-    return
-  }
-
-  if (
-    declarationWithoutComments.startsWith('interface')
-    || declarationWithoutComments.startsWith('export interface')
-  ) {
-    const processed = processInterface(
-      fullDeclaration,
-      declarationWithoutComments.startsWith('export'),
-    )
-    state.dtsLines.push(processed)
-    return
-  }
-
-  if (
-    declarationWithoutComments.startsWith('type')
-    || declarationWithoutComments.startsWith('export type')
-  ) {
-    const processed = processType(
-      fullDeclaration,
-      declarationWithoutComments.startsWith('export'),
-    )
-    state.dtsLines.push(processed)
-    return
-  }
-
-  if (
-    declarationWithoutComments.startsWith('function')
-    || declarationWithoutComments.startsWith('export function')
-    || declarationWithoutComments.startsWith('async function')
-    || declarationWithoutComments.startsWith('export async function')
-  ) {
-
-    const processed = processFunction(
-      fullDeclaration,
-      state.usedTypes,
-      declarationWithoutComments.startsWith('export'),
-    )
-    state.dtsLines.push(processed)
-    return
-  }
-
-  if (declarationWithoutComments.startsWith('export *')) {
-    state.exportAllStatements.push(declarationWithoutComments)
-    state.dtsLines.push(fullDeclaration)
-    return
-  }
-
-  if (declarationWithoutComments.startsWith('export {')) {
-    state.dtsLines.push(fullDeclaration)
-    return
-  }
-
-  if (declarationWithoutComments.startsWith('export type {')) {
-    state.dtsLines.push(fullDeclaration)
-    return
-  }
-
-  if (
-    declarationWithoutComments.startsWith('class')
-    || declarationWithoutComments.startsWith('export class')
-    || declarationWithoutComments.startsWith('abstract class')
-    || declarationWithoutComments.startsWith('export abstract class')
-  ) {
-    const isExported = declarationWithoutComments.startsWith('export')
-    const processed = `${isExported ? 'export ' : ''}declare ${declarationWithoutComments.replace(/^export\s+/, '')}`
-    state.dtsLines.push(processed)
-    return
-  }
-
-  if (
-    declarationWithoutComments.startsWith('enum')
-    || declarationWithoutComments.startsWith('export enum')
-    || declarationWithoutComments.startsWith('const enum')
-    || declarationWithoutComments.startsWith('export const enum')
-  ) {
-    const isExported = declarationWithoutComments.startsWith('export')
-    const processed = `${isExported ? 'export ' : ''}declare ${declarationWithoutComments.replace(/^export\s+/, '')}`
-    state.dtsLines.push(processed)
-    return
-  }
-
-  if (
-    declarationWithoutComments.startsWith('namespace')
-    || declarationWithoutComments.startsWith('export namespace')
-  ) {
-    const isExported = declarationWithoutComments.startsWith('export')
-    const processed = `${isExported ? 'export ' : ''}declare ${declarationWithoutComments.replace(/^export\s+/, '')}`
-    state.dtsLines.push(processed)
-    return
-  }
-
-  if (
-    declarationWithoutComments.startsWith('let')
-    || declarationWithoutComments.startsWith('export let')
-    || declarationWithoutComments.startsWith('var')
-    || declarationWithoutComments.startsWith('export var')
-  ) {
-    const isExported = declarationWithoutComments.startsWith('export')
-    const processed = `${isExported ? 'export ' : ''}declare ${declarationWithoutComments.replace(/^export\s+/, '')}`
-    state.dtsLines.push(processed)
-    return
-  }
-
-  console.warn('Unhandled declaration type:', declarationWithoutComments.split('\n')[0])
-}
-
-function processSourceFile(content: string, state: ProcessingState): void {
-  const lines = content.split('\n')
-  let currentBlock: string[] = []
-  let currentComments: string[] = []
-  let bracketDepth = 0
-  let angleDepth = 0
-  let inDeclaration = false
-  state.currentScope = 'top'
-
-  debugLog('source-processing', `Processing source file with ${lines.length} lines`)
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]
-    const trimmedLine = line.trim()
-
-    debugLog('source-scan', `First pass - Line ${i + 1}: ${trimmedLine}`)
-
-    if (line.includes('import ')) {
-      processImports(line, state.importTracking)
-      debugLog('import', `Processed import: ${line}`)
-    }
-
-    if (trimmedLine.startsWith('export type {')) {
-      debugLog('type-export', `Found type export: ${trimmedLine}`)
-      processTypeExport(trimmedLine, state)
-      state.dtsLines.push(line)
-      continue
-    }
-
-    if (trimmedLine.startsWith('export {')) {
-      debugLog('mixed-export', `Found mixed export: ${trimmedLine}`)
-      processExport(trimmedLine, state)
-      state.dtsLines.push(line)
-      continue
-    }
-  }
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i]
-    const trimmedLine = line.trim()
-
-    if (trimmedLine.startsWith('import ')
-      || trimmedLine.startsWith('export type {')
-      || trimmedLine.startsWith('export {')) {
-      continue
-    }
-
-    if (trimmedLine.startsWith('g, '$1')
-    .replace(/\s*,\s*/g, ', ')
-    .trim()
-}
-
-function normalizePropertyKey(key: string): string {
-  const cleanKey = key.replace(/^['"`]|['"`]$/g, '')
-
-  if (!/^[a-z_$][\w$]*$/i.test(cleanKey)) {
-    return `'${cleanKey}'`
-  }
-
-  return cleanKey
-}
-
-function splitArrayElements(content: string): string[] {
-  const elements: string[] = []
-  let current = ''
-  let depth = 0
-  let inString = false
-  let stringChar = ''
-
-  for (let i = 0; i < content.length; i++) {
-    const char = content[i]
-    const prevChar = i > 0 ? content[i - 1] : ''
-
-    if ((char === '"' || char === '\'' || char === '`') && prevChar !== '\\') {
-      if (!inString) {
-        inString = true
-        stringChar = char
-      }
-      else if (char === stringChar) {
-        inString = false
-      }
-    }
-
-    if (!inString) {
-      if (char === '[' || char === '{' || char === '(') {
-        depth++
-      }
-      else if (char === ']' || char === '}' || char === ')') {
-        depth--
-      }
-      else if (char === ',' && depth === 0) {
-        const trimmed = current.trim()
-        if (trimmed) {
-          elements.push(trimmed)
-        }
-        current = ''
-        continue
-      }
-    }
-
-    current += char
-  }
-
-  const trimmed = current.trim()
-  if (trimmed) {
-    elements.push(trimmed)
-  }
-
-  return elements
-}
-
-function splitFunctionDeclarations(content: string): string[] {
-  const declarations: string[] = []
-  const lines = content.split('\n')
-  let current: string[] = []
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i].trim()
-
-    if ((line.startsWith('export function') || line.startsWith('function')) && current.length > 0) {
-      declarations.push(current.join('\n'))
-      current = []
-    }
-
-    current.push(lines[i])
-  }
-
-  if (current.length > 0) {
-    declarations.push(current.join('\n'))
-  }
-
-  return declarations
-}
+declare function extractParams(rest: string);
+declare function extractReturnType(rest: string);
+declare function extractFunctionType(value: string): string | null;
+declare function generateOptimizedImports(state: ImportTrackingState): string[];
+declare function extractCompleteObjectContent(value: string): string | null;
+declare function formatOutput(state: ProcessingState): string;
+declare function removeLeadingComments(code: string): string;
+declare function createProcessingState(): ProcessingState;
+declare function createImportTrackingState(): ImportTrackingState;
+declare function indentMultilineType(type: string, baseIndent: string, isLast: boolean): string;
+declare function inferValueType(value: string): string;
+declare function inferArrayType(value: string, state?: ProcessingState, preserveLineBreaks = false): string;
+declare function inferComplexObjectType(value: string, state?: ProcessingState, indentLevel = 0): string;
+declare function inferConstArrayType(value: string, state?: ProcessingState): string;
+declare function inferConstType(value: string, state: ProcessingState): string;
+declare function inferTypeFromDefaultValue(defaultValue: string): string;
+declare function isDefaultExport(line: string): boolean;
+declare function isDeclarationStart(line: string): boolean;
+declare function isRegexPattern(line: string): boolean;
+declare function isBrandedType(declaration: string): boolean;
+export declare function isFunctionType(type: string): boolean;
+export declare function isDeclarationComplete(content: string | string[]): boolean;
+declare function isVariableInsideFunction(line: string, state: ProcessingState): boolean;
+declare function needsMultilineFormat(types: string[]): boolean;
+declare function normalizeTypeReference(value: string): string;
+declare function processBlock(lines: string[], comments: string[], state: ProcessingState): void;
+declare function processVariableBlock(cleanDeclaration: string, lines: string[], state: ProcessingState): boolean;
+declare function processFunctionBlock(cleanDeclaration: string, state: ProcessingState): boolean;
+declare function processInterfaceBlock(cleanDeclaration: string, declarationText: string, state: ProcessingState): boolean;
+declare function processTypeBlock(cleanDeclaration: string, declarationText: string, state: ProcessingState): boolean;
+declare function processDefaultExportBlock(cleanDeclaration: string, state: ProcessingState): boolean;
+declare function processExportAllBlock(cleanDeclaration: string, state: ProcessingState): boolean;
+declare function processExportBlock(cleanDeclaration: string, declarationText: string, state: ProcessingState): boolean;
+declare function processExport(line: string, state: ProcessingState): void;
+declare function processExportedClass(cleanDeclaration: string, state: ProcessingState): boolean;
+declare function processExportedEnum(cleanDeclaration: string, state: ProcessingState): boolean;
+declare function processExportedNamespace(cleanDeclaration: string, state: ProcessingState): boolean;
+declare function processModuleBlock(cleanDeclaration: string, declarationText: string, state: ProcessingState): boolean;
+export declare function processSpecificDeclaration(declarationWithoutComments: string, fullDeclaration: string, state: ProcessingState): void;
+declare function processSourceFile(content: string, state: ProcessingState): void;
+declare function processImports(line: string, state: ImportTrackingState): void;
+declare function processType(declaration: string, isExported = true): string;
+declare function processTypeExport(line: string, state: ProcessingState): void;
+declare function processVariable(declaration: string, isExported: boolean, state: ProcessingState): string;
+declare function processFunction(declaration: string, usedTypes?: Set<string>, isExported = true): string;
+declare function getCleanDeclaration(declaration: string): string;
+declare function processGeneratorFunction(declaration: string): string;
+declare function processInterface(declaration: string, isExported = true): string;
+declare function processModule(declaration: string): string;
+declare function processObjectMethod(declaration: string): ProcessedMethod;
+declare function processObjectProperties(content: string, state?: ProcessingState, indentLevel = 0): Array<{ key: string, value: string }>;
+declare function processPropertyValue(value: string, indentLevel: number, state?: ProcessingState): string;
+declare function trackTypeUsage(content: string, state: ImportTrackingState): void;
+declare function trackValueUsage(content: string, state: ImportTrackingState): void;
+declare function debugLog(category: string, message: string): void;
+declare function normalizeType(type: string): string;
+declare function normalizePropertyKey(key: string): string;
+declare function splitArrayElements(content: string): string[];
+declare function splitFunctionDeclarations(content: string): string[];