@dtsx/dtsx 0.0.0-stage → 0.11.38

package/dist/src/lsp.d.ts

@@ -0,0 +1,333 @@
+/**
+ * Start LSP server on stdio
+ */
+export declare function startLSPServer(): void;
+/**
+ * Create a simple file watcher that emits diagnostics
+ */
+export declare function createFileWatcher(server: DtsxLanguageServer, onDiagnostics: (uri: string, diagnostics: Diagnostic[]) => void): (filePath: string) => void;
+/**
+ * LSP message types
+ */
+export declare interface LSPMessage {
+  jsonrpc: '2.0'
+  id?: number | string
+  method?: string
+  params?: unknown
+  result?: unknown
+  error?: LSPError
+}
+export declare interface LSPError {
+  code: number
+  message: string
+  data?: unknown
+}
+/**
+ * LSP initialization params
+ */
+export declare interface InitializeParams {
+  processId: number | null
+  rootUri: string | null
+  capabilities: ClientCapabilities
+}
+export declare interface ClientCapabilities {
+  textDocument?: {
+    synchronization?: {
+      dynamicRegistration?: boolean
+      willSave?: boolean
+      didSave?: boolean
+    }
+    hover?: {
+      dynamicRegistration?: boolean
+      contentFormat?: string[]
+    }
+    completion?: {
+      dynamicRegistration?: boolean
+      completionItem?: {
+        snippetSupport?: boolean
+        documentationFormat?: string[]
+      }
+    }
+    definition?: {
+      dynamicRegistration?: boolean
+    }
+    diagnostic?: {
+      dynamicRegistration?: boolean
+    }
+  }
+  workspace?: {
+    workspaceFolders?: boolean
+    configuration?: boolean
+  }
+}
+export declare interface ServerCapabilities {
+  textDocumentSync?: number
+  hoverProvider?: boolean
+  completionProvider?: {
+    triggerCharacters?: string[]
+    resolveProvider?: boolean
+  }
+  definitionProvider?: boolean
+  referencesProvider?: boolean
+  renameProvider?: boolean | { prepareProvider?: boolean }
+  documentSymbolProvider?: boolean
+  workspaceSymbolProvider?: boolean
+  codeActionProvider?: boolean | { codeActionKinds?: string[] }
+  signatureHelpProvider?: {
+    triggerCharacters?: string[]
+    retriggerCharacters?: string[]
+  }
+  documentHighlightProvider?: boolean
+  documentFormattingProvider?: boolean
+  diagnosticProvider?: {
+    interFileDependencies: boolean
+    workspaceDiagnostics: boolean
+  }
+}
+/**
+ * Text document item
+ */
+export declare interface TextDocumentItem {
+  uri: string
+  languageId: string
+  version: number
+  text: string
+}
+/**
+ * Position in a text document
+ */
+export declare interface Position {
+  line: number
+  character: number
+}
+/**
+ * Range in a text document
+ */
+export declare interface Range {
+  start: Position
+  end: Position
+}
+/**
+ * Diagnostic message
+ */
+export declare interface Diagnostic {
+  range: Range
+  severity?: LspDiagnosticSeverity
+  code?: string | number
+  source?: string
+  message: string
+}
+/**
+ * Hover response
+ */
+export declare interface Hover {
+  contents: string | { kind: string, value: string }
+  range?: Range
+}
+/**
+ * Location for go-to-definition
+ */
+export declare interface Location {
+  uri: string
+  range: Range
+}
+/**
+ * Document symbol
+ */
+export declare interface DocumentSymbol {
+  name: string
+  detail?: string
+  kind: SymbolKind
+  range: Range
+  selectionRange: Range
+  children?: DocumentSymbol[]
+}
+/**
+ * Workspace symbol
+ */
+export declare interface WorkspaceSymbol {
+  name: string
+  kind: SymbolKind
+  location: Location
+  containerName?: string
+}
+/**
+ * Code action
+ */
+export declare interface CodeAction {
+  title: string
+  kind?: string
+  diagnostics?: Diagnostic[]
+  isPreferred?: boolean
+  edit?: WorkspaceEdit
+  command?: Command
+}
+/**
+ * Workspace edit
+ */
+export declare interface WorkspaceEdit {
+  changes?: Record<string, TextEdit[]>
+}
+/**
+ * Text edit
+ */
+export declare interface TextEdit {
+  range: Range
+  newText: string
+}
+/**
+ * Command
+ */
+export declare interface Command {
+  title: string
+  command: string
+  arguments?: unknown[]
+}
+/**
+ * Signature help
+ */
+export declare interface SignatureHelp {
+  signatures: SignatureInformation[]
+  activeSignature?: number
+  activeParameter?: number
+}
+/**
+ * Signature information
+ */
+export declare interface SignatureInformation {
+  label: string
+  documentation?: string | { kind: string, value: string }
+  parameters?: ParameterInformation[]
+}
+/**
+ * Parameter information
+ */
+export declare interface ParameterInformation {
+  label: string | [number, number]
+  documentation?: string | { kind: string, value: string }
+}
+/**
+ * Document highlight
+ */
+export declare interface DocumentHighlight {
+  range: Range
+  kind?: DocumentHighlightKind
+}
+/**
+ * LSP Server for dtsx
+ */
+export declare class DtsxLanguageServer {
+  private documents;
+  private rootUri;
+  private config;
+  private messageId;
+  private watchers;
+  initialize(params: InitializeParams): { capabilities: ServerCapabilities };
+  didOpen(params: { textDocument: TextDocumentItem }): void;
+  didChange(params: { textDocument: { uri: string, version: number }, contentChanges: Array<{ text: string }> }): void;
+  didClose(params: { textDocument: { uri: string } }): void;
+  private updateDocument;
+  getDiagnostics(uri: string): Diagnostic[];
+  hover(params: { textDocument: { uri: string }, position: Position }): Hover | null;
+  completion(params: { textDocument: { uri: string }, position: Position }): Array<{ label: string, kind: number, detail?: string, documentation?: string }>;
+  definition(params: { textDocument: { uri: string }, position: Position }): Location | null;
+  references(params: { textDocument: { uri: string }, position: Position, context: { includeDeclaration: boolean } }): Location[];
+  prepareRename(params: { textDocument: { uri: string }, position: Position }): { range: Range, placeholder: string } | null;
+  rename(params: { textDocument: { uri: string }, position: Position, newName: string }): WorkspaceEdit | null;
+  documentSymbols(params: { textDocument: { uri: string } }): DocumentSymbol[];
+  workspaceSymbols(params: { query: string }): WorkspaceSymbol[];
+  codeActions(params: { textDocument: { uri: string }, range: Range, context: { diagnostics: Diagnostic[] } }): CodeAction[];
+  signatureHelp(params: { textDocument: { uri: string }, position: Position }): SignatureHelp | null;
+  documentHighlight(params: { textDocument: { uri: string }, position: Position }): DocumentHighlight[];
+  formatting(params: { textDocument: { uri: string }, options: { tabSize: number, insertSpaces: boolean } }): Promise<TextEdit[]>;
+  private getWordAtPosition;
+  private getWordAtRange;
+  private getDeclarationAtPosition;
+  private positionInRange;
+  private declarationKindToSymbolKind;
+  generateDts(uri: string): string | null;
+  private buildSignature;
+  private getDeclarationRange;
+  private offsetToPosition;
+  private uriToPath;
+  private pathToUri;
+  handleMessage(message: LSPMessage): LSPMessage | null;
+}
+/**
+ * LSP Diagnostic severity (matches LSP specification)
+ */
+export declare enum LspDiagnosticSeverity {
+  Error = 1,
+  Warning = 2,
+  Information = 3,
+  Hint = 4,
+}
+/**
+ * Symbol kind enum (LSP spec)
+ */
+export declare enum SymbolKind {
+  File = 1,
+  Module = 2,
+  Namespace = 3,
+  Package = 4,
+  Class = 5,
+  Method = 6,
+  Property = 7,
+  Field = 8,
+  Constructor = 9,
+  Enum = 10,
+  Interface = 11,
+  Function = 12,
+  Variable = 13,
+  Constant = 14,
+  String = 15,
+  Number = 16,
+  Boolean = 17,
+  Array = 18,
+  Object = 19,
+  Key = 20,
+  Null = 21,
+  EnumMember = 22,
+  Struct = 23,
+  Event = 24,
+  Operator = 25,
+  TypeParameter = 26,
+}
+/**
+ * Completion item kind enum
+ */
+export declare enum CompletionItemKind {
+  Text = 1,
+  Method = 2,
+  Function = 3,
+  Constructor = 4,
+  Field = 5,
+  Variable = 6,
+  Class = 7,
+  Interface = 8,
+  Module = 9,
+  Property = 10,
+  Unit = 11,
+  Value = 12,
+  Enum = 13,
+  Keyword = 14,
+  Snippet = 15,
+  Color = 16,
+  File = 17,
+  Reference = 18,
+  Folder = 19,
+  EnumMember = 20,
+  Constant = 21,
+  Struct = 22,
+  Event = 23,
+  Operator = 24,
+  TypeParameter = 25,
+}
+/**
+ * Document highlight kind
+ */
+export declare enum DocumentHighlightKind {
+  Text = 1,
+  Read = 2,
+  Write = 3,
+}

package/dist/src/lsp.js

@@ -0,0 +1,2 @@
+// @bun
+import{Dr,Rr,Mr,Or,Yt,As,Ps}from"../chunk-8tzd98q8.js";import"../chunk-y1g6v96c.js";import"../chunk-zk3w5sqv.js";import"../chunk-4fygcxtb.js";import"../chunk-jcckwgb9.js";import"../chunk-189nn4fc.js";import"../chunk-83qnrx0m.js";import"../chunk-sd8bywh9.js";import"../chunk-3fbt79hx.js";import"../chunk-pga5m4wm.js";import"../chunk-v6fwy63g.js";import"../chunk-yx1jy7fx.js";import"../chunk-cyr45de1.js";import"../chunk-xfjfhe9d.js";import"../chunk-xa6rsd4b.js";import"../chunk-ft2zk7jx.js";import"../chunk-vf3ybe5r.js";import"../chunk-3t57mzvf.js";import"../chunk-ag1b6d30.js";import"../chunk-8d3sdkv4.js";import"../chunk-cv29b4zb.js";import"../chunk-32qexm3w.js";import"../chunk-0rmbc5zp.js";import"../chunk-42j9cfte.js";import"../chunk-1qtghb2x.js";import"../chunk-1j6092xz.js";import"../chunk-zq93f8ca.js";export{Mr as CompletionItemKind,Or as DocumentHighlightKind,Yt as DtsxLanguageServer,Dr as LspDiagnosticSeverity,Rr as SymbolKind,Ps as createFileWatcher,As as startLSPServer};

package/dist/src/memory.d.ts

@@ -0,0 +1,127 @@
+import type { Declaration, DtsGenerationConfig } from './types.js';
+/**
+ * Create memory-optimized configuration
+ */
+export declare function createMemoryOptimizedConfig(baseConfig: DtsGenerationConfig, memoryConfig?: MemoryConfig): DtsGenerationConfig & { memory: Required<MemoryConfig> };
+/**
+ * Estimate memory usage for a file
+ */
+export declare function estimateMemoryUsage(filePath: string): {
+  fileSizeMB: number
+  estimatedMemoryMB: number
+  recommendedChunkSize: number
+};
+/**
+ * Format memory stats for display
+ */
+export declare function formatMemoryStats(stats: MemoryStats): string;
+/**
+ * Create a streaming processor with default config
+ */
+export declare function createStreamingProcessor(config?: MemoryConfig): StreamingProcessor;
+/**
+ * Memory configuration options
+ */
+export declare interface MemoryConfig {
+  maxMemoryMB?: number
+  chunkSize?: number
+  aggressiveGC?: boolean
+  maxDeclarationsInMemory?: number
+  profile?: boolean
+  cleanupInterval?: number
+}
+/**
+ * Memory usage statistics
+ */
+export declare interface MemoryStats {
+  heapUsed: number
+  heapTotal: number
+  external: number
+  arrayBuffers: number
+  rss: number
+  heapUsedMB: number
+  percentUsed: number
+}
+/**
+ * Memory profiling entry
+ */
+export declare interface MemoryProfile {
+  timestamp: number
+  operation: string
+  memoryBefore: MemoryStats
+  memoryAfter: MemoryStats
+  duration: number
+}
+/**
+ * Streaming file processor for large files
+ */
+export declare class StreamingProcessor {
+  private config;
+  private profiles;
+  private cleanupTimer;
+  constructor(config?: MemoryConfig);
+  startMonitoring(): void;
+  stopMonitoring(): void;
+  private checkMemoryAndCleanup;
+  triggerCleanup(): void;
+  getMemoryStats(): MemoryStats;
+  profile<T>(operation: string, fn: () => Promise<T>): Promise<T>;
+  getProfiles(): MemoryProfile[];
+  clearProfiles(): void;
+  streamFile(filePath: string): AsyncGenerator<string, void, unknown>;
+  processFileInChunks<T>(filePath: string, processor: (chunk: string[]) => Promise<T[]>, chunkLines?: number): Promise<T[]>;
+  streamWrite(filePath: string, contentGenerator: AsyncGenerator<string>): Promise<void>;
+}
+/**
+ * Declaration pool for memory-efficient declaration management
+ */
+export declare class DeclarationPool {
+  private declarations;
+  private registry;
+  private maxSize;
+  constructor(maxSize?: number);
+  add(key: string, declaration: Declaration): void;
+  get(key: string): Declaration | undefined;
+  has(key: string): boolean;
+  delete(key: string): void;
+  clear(): void;
+  get size(): number;
+  private evictOldest;
+}
+/**
+ * Lazy loading wrapper for large objects
+ */
+export declare class LazyLoader<T> {
+  private value;
+  private loaded;
+  private loader;
+  constructor(loader: () => T | Promise<T>);
+  get(): Promise<T>;
+  isLoaded(): boolean;
+  unload(): void;
+}
+/**
+ * String interning for memory efficiency
+ */
+export declare class StringInterner {
+  private strings;
+  private maxSize;
+  constructor(maxSize?: number);
+  intern(str: string): string;
+  get size(): number;
+  clear(): void;
+}
+/**
+ * Object pool for reusing declaration objects
+ */
+export declare class ObjectPool<T> {
+  private pool;
+  private factory;
+  private reset;
+  private maxSize;
+  constructor(factory: () => T, reset: (obj: T) => void, maxSize?: number);
+  acquire(): T;
+  release(obj: T): void;
+  get size(): number;
+  clear(): void;
+}

package/dist/src/memory.js

@@ -0,0 +1,2 @@
+// @bun
+import{Gt,hr,yr,br,wr,ds,ps,ms,gs}from"../chunk-2436cnmb.js";export{hr as DeclarationPool,yr as LazyLoader,wr as ObjectPool,Gt as StreamingProcessor,br as StringInterner,ds as createMemoryOptimizedConfig,gs as createStreamingProcessor,ps as estimateMemoryUsage,ms as formatMemoryStats};

package/dist/src/merger.d.ts

@@ -0,0 +1,38 @@
+import type { Declaration } from './types.js';
+/**
+ * Merge declarations with the same name
+ */
+export declare function mergeDeclarations(declarations: Declaration[], config?: MergeConfig): MergeResult;
+/**
+ * Merge declarations in content string
+ */
+export declare function mergeDeclarationsInContent(content: string, _config?: MergeConfig): string;
+/**
+ * Merge configuration
+ */
+export declare interface MergeConfig {
+  mergeInterfaces?: boolean
+  mergeNamespaces?: boolean
+  mergeTypes?: boolean
+  mergeEnums?: boolean
+  deduplicateIdentical?: boolean
+  conflictStrategy?: 'first' | 'last' | 'error'
+  preserveAllComments?: boolean
+}
+/**
+ * Result of merge operation
+ */
+export declare interface MergeResult {
+  declarations: Declaration[]
+  mergedCount: number
+  merges: MergeDetail[]
+}
+/**
+ * Details of a single merge
+ */
+export declare interface MergeDetail {
+  name: string
+  kind: string
+  sourceCount: number
+  memberCount: number
+}

package/dist/src/merger.js

@@ -0,0 +1,2 @@
+// @bun
+import{Bi,Wi}from"../chunk-kkshxyex.js";export{Bi as mergeDeclarations,Wi as mergeDeclarationsInContent};

package/dist/src/module-graph.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Resolve a relative re-export specifier to an absolute path on disk.
+ *
+ * Resolves local specifiers to normalized absolute native paths. Bare
+ * specifiers (e.g. `react`, `@scope/foo`) return `{ resolved: null }`.
+ */
+export declare function resolveRelativeSpecifier(specifier: string, fromFile: string): ResolveResult;
+/** Share local alias ownership between graph traversal and declaration output. */
+export declare function createModuleResolver(options: ModuleResolutionOptions): Promise<ModuleResolver>;
+/**
+ * Scan grammatical module references. Re-exports are returned first, followed
+ * by static imports and import types, preserving each group's source order.
+ */
+export declare function scanReExportSpecifiers(source: string, options?: { includeImports?: boolean }): ReExportRef[];
+/** Rewrite only module literals, preserving raw spelling when their value is unchanged. */
+export declare function rewriteModuleSpecifiers(source: string, rewrite: (specifier: string) => string): string;
+/**
+ * BFS the re-export graph starting from `entrypoints`.
+ *
+ * Each entrypoint and every file reached via `export … from './x'`
+ * (recursively, with normalized path identities and cycle protection) ends up in `reachable`. Files
+ * whose source can't be read are skipped silently — the caller is the
+ * one with the right context to decide whether that's an error.
+ */
+export declare function collectReachableViaReExports(entrypoints: string[], options?: { includeImports?: boolean, resolveSpecifier?: ModuleResolver }): Promise<ReachabilityResult>;
+/**
+ * A single relative re-export or import reference parsed out of source.
+ */
+export declare interface ReExportRef {
+  specifier: string
+  kind: 'export-star' | 'export-star-as' | 'export-named' | 'import'
+  isTypeOnly: boolean
+}
+/**
+ * Result of resolving a specifier to disk.
+ */
+export declare interface ResolveResult {
+  resolved: string | null
+  isRelative: boolean
+  isAlias?: boolean
+  suffix?: string
+}
+export declare interface ModuleResolutionOptions {
+  cwd: string
+  root: string
+  tsconfigPath?: string
+  outputStructure?: 'mirror' | 'flat'
+}
+export declare interface ModuleResolver {
+  (specifier: string, fromFile: string): ResolveResult
+  isPackageLocal?: (fromFile: string, target: string) => boolean
+  cacheKey?: (files: string[]) => string
+}
+/**
+ * An unresolved relative re-export discovered during traversal.
+ */
+export declare interface UnresolvedReExport {
+  from: string
+  specifier: string
+  isTypeOnly: boolean
+}
+/**
+ * Result of walking the re-export graph from a set of entrypoints.
+ */
+export declare interface ReachabilityResult {
+  reachable: Set<string>
+  reExports: Map<string, ReExportRef[]>
+  unresolved: UnresolvedReExport[]
+  sources: ReadonlyMap<string, string>
+}

package/dist/src/module-graph.js

@@ -0,0 +1,2 @@
+// @bun
+import{Y,Ce,k,Sn,V}from"../chunk-p9vfxn8g.js";import"../chunk-qzjzw9p2.js";import"../chunk-cpmqa8kd.js";import"../chunk-73dzve1s.js";import"../chunk-yay68832.js";import"../chunk-1j6092xz.js";import"../chunk-zq93f8ca.js";export{V as collectReachableViaReExports,Ce as createModuleResolver,Y as resolveRelativeSpecifier,Sn as rewriteModuleSpecifiers,k as scanReExportSpecifiers};

package/dist/src/module-references.d.ts

@@ -0,0 +1,30 @@
+export declare function tokenizeDeclarationSyntax(source: string): SyntaxToken[];
+/**
+ * Tokens of a whole source file, shared by the analyses of one scan (module
+ * detection, expando properties, call inference) instead of re-lexing the
+ * same text for each. The array is read-only and reused for the same string.
+ */
+export declare function sourceSyntaxTokens(source: string): readonly SyntaxToken[];
+/** Drop the shared whole-source tokens (part of clearing extraction caches). */
+export declare function clearSourceSyntaxTokens(): void;
+/** Decode a quoted module literal without executing or transpiling source. */
+export declare function decodeStringLiteral(literal: string): string | undefined;
+/** Preserve the caller's quote style while safely spelling a new module value. */
+export declare function quoteModuleSpecifier(value: string, quote: string): string;
+/** Parse one complete external import-equals declaration, including trivia. */
+export declare function parseImportEquals(source: string): { name: string, source: string, isTypeOnly: boolean, end: number } | undefined;
+/** Source-order grammatical module literals, retaining spans for safe rewriting. */
+export declare function scanModuleReferences(source: string): ModuleReference[];
+export declare interface SyntaxToken {
+  start: number
+  end: number
+  kind: 'word' | 'quoted' | 'punctuation' | 'literal'
+}
+export declare interface ModuleReference {
+  specifier: string
+  kind: 'export-star' | 'export-star-as' | 'export-named' | 'import'
+  isTypeOnly: boolean
+  category: 'export' | 'static-import' | 'import-type' | 'augmentation'
+  start: number
+  end: number
+}

package/dist/src/module-references.js

@@ -0,0 +1,2 @@
+// @bun
+import{t,F,Jn,d,x,Me,m}from"../chunk-1j6092xz.js";import"../chunk-zq93f8ca.js";export{Jn as clearSourceSyntaxTokens,d as decodeStringLiteral,Me as parseImportEquals,x as quoteModuleSpecifier,m as scanModuleReferences,F as sourceSyntaxTokens,t as tokenizeDeclarationSyntax};

package/dist/src/native-checker.d.ts

@@ -0,0 +1,55 @@
+import type { DtsGenerationConfig } from './types.js';
+export declare function loadCompilerOptions(path: string, overrides?: CompilerOptions): CompilerOptions;
+export declare function typeCheck(files: string[], config?: TypeCheckConfig): Promise<TypeCheckResult>;
+export declare function validateDeclarations(files: string[], config?: TypeCheckConfig): Promise<TypeCheckResult>;
+export declare function checkIsolatedDeclarations(files: string[]): Promise<Map<string, IsolatedDeclarationsResult>>;
+export declare function getTypeAtPosition(file: string, line: number, column: number): string | null;
+export declare function getQuickInfo(file: string, line: number, column: number): { type: string, documentation?: string } | null;
+export declare function formatTypeCheckResults(result: TypeCheckResult): string;
+export declare function typeCheckWithConfig(config: DtsGenerationConfig): Promise<TypeCheckResult>;
+export declare function validateGeneratedDeclarations(sourceFiles: string[], declarationFiles: string[]): Promise<{ valid: boolean, mismatches: Array<{ sourceName: string, sourceType: string, dtsType: string }> }>;
+export declare interface TypeDiagnostic {
+  file: string
+  line: number
+  column: number
+  message: string
+  code: number
+  severity: DiagnosticSeverity
+  source?: string
+  suggestion?: string
+  category: string
+}
+export declare interface TypeCheckResult {
+  success: boolean
+  diagnostics: TypeDiagnostic[]
+  errorCount: number
+  warningCount: number
+  infoCount: number
+  filesChecked: string[]
+  durationMs: number
+}
+export declare interface TypeCheckConfig {
+  tsconfigPath?: string
+  rootDir?: string
+  strict?: boolean
+  declarationsOnly?: boolean
+  skipLibCheck?: boolean
+  include?: string[]
+  exclude?: string[]
+  warningsAsErrors?: boolean
+  maxErrors?: number
+  compilerOptions?: CompilerOptions
+}
+export declare interface IsolatedDeclarationsIssue {
+  line: number
+  column: number
+  message: string
+  declarationName?: string
+  missingAnnotation?: 'return' | 'parameter' | 'variable' | 'property'
+}
+export declare interface IsolatedDeclarationsResult {
+  compatible: boolean
+  issues: IsolatedDeclarationsIssue[]
+}
+export type DiagnosticSeverity = 'error' | 'warning' | 'info' | 'hint';
+export type CompilerOptions = Record<string, unknown>;

package/dist/src/native-checker.js

@@ -0,0 +1,2 @@
+// @bun
+import{hs,at,xr,ys,Cr,bs,ws,xs,Cs}from"../chunk-a7nvyxpg.js";import"../chunk-danfamyx.js";import"../chunk-jcckwgb9.js";import"../chunk-189nn4fc.js";import"../chunk-83qnrx0m.js";import"../chunk-sd8bywh9.js";import"../chunk-3fbt79hx.js";import"../chunk-pga5m4wm.js";import"../chunk-v6fwy63g.js";import"../chunk-yx1jy7fx.js";import"../chunk-cyr45de1.js";import"../chunk-xfjfhe9d.js";import"../chunk-xa6rsd4b.js";import"../chunk-ft2zk7jx.js";import"../chunk-vf3ybe5r.js";import"../chunk-3t57mzvf.js";import"../chunk-ag1b6d30.js";import"../chunk-8d3sdkv4.js";import"../chunk-cv29b4zb.js";import"../chunk-32qexm3w.js";import"../chunk-0rmbc5zp.js";import"../chunk-42j9cfte.js";import"../chunk-1qtghb2x.js";import"../chunk-1j6092xz.js";import"../chunk-zq93f8ca.js";export{ys as checkIsolatedDeclarations,ws as formatTypeCheckResults,bs as getQuickInfo,Cr as getTypeAtPosition,hs as loadCompilerOptions,at as typeCheck,xs as typeCheckWithConfig,xr as validateDeclarations,Cs as validateGeneratedDeclarations};

package/dist/src/native-engine.d.ts

@@ -0,0 +1,16 @@
+/** Whether declaration emission can run on the native engine in this process. */
+export declare function nativeEngineAvailable(): boolean;
+/**
+ * Emit declarations natively. Returns `null` when the engine is unavailable or
+ * the native emitter rejects the input, so the caller can use the TypeScript
+ * engine instead.
+ */
+export declare function emitWithNativeEngine(source: string, options: NativeEmitOptions): string | null;
+/** Options for one native emission. */
+export declare interface NativeEmitOptions {
+  keepComments: boolean
+  isolatedDeclarations: boolean
+  sourceFile?: string
+  inferenceSources?: ReadonlyMap<string, string>
+  augmentationImports?: ReadonlySet<string>
+}