import { VersionResolver } from './versionResolver.js';
import type { PackageRanges } from './types.js';
import { CdnClient } from './cdnClient.js';
import { PeerResolver } from './peerResolver.js';
export type ImportMap = {
    imports: Record<string, string>;
};
export declare class PackageService {
    private version;
    private cdn;
    private peer;
    private static importPatterns;
    constructor(version: VersionResolver, cdn: CdnClient, peer: PeerResolver);
    /** Fast sync import extraction using regex (for quick comparisons) */
    extractImportsSync(source: string): string[];
    /** Async import extraction using es-module-lexer (more accurate) */
    extractImports(source: string): Promise<string[]>;
    /**
     * Build an import map for a bulb's code.
     *
     * `skipRoots` names roots the caller supplies itself (serving them from
     * elsewhere); their imports are dropped before resolution, so they're never
     * looked up on the CDN. Optional and caller-agnostic — callers that resolve
     * the whole graph simply omit it.
     */
    buildImportMap(code: string, ranges: PackageRanges, skipRoots?: ReadonlySet<string>): Promise<{
        importMap: {
            imports: {
                [k: string]: string;
            };
        };
        prefetchUrls: string[];
    }>;
    /** Resolution is `resolveExactForRoot`'s pipeline or a clear failure — never an unpinned range.
     *  (Its final step already probes esm.sh, exact-version-guarded, so a registry outage still
     *  resolves when the CDN redirect names an exact version.) */
    private resolveVersion;
    private buildEntries;
    /** Get dependencies (peer or regular) that are singletons and need to be externalized */
    private singletonDepsOf;
}
//# sourceMappingURL=packageService.d.ts.map