@stacksjs/dtsx 0.6.0 → 0.6.1

package/dist/extract.d.ts

@@ -1,4 +1,4 @@
-import type { FunctionSignature } from './types';
+import type { FunctionSignature, ImportTrackingState, ProcessedMethod, ProcessingState } from './types';
 
 declare function cleanParameterTypes(params: string): string;
 declare function cleanSingleParameter(param: string): string;
@@ -6,4 +6,1314 @@ export declare function extract(filePath: string): Promise<string>;
 export declare function extractDtsTypes(sourceCode: string): string;
 declare function extractFunctionSignature(declaration: string): FunctionSignature;
 declare function extractFunctionName(declaration: string): string;
-declare function extractParams(rest: 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
+}