@mks2508/bundlp 0.1.0

package/README.md

@@ -0,0 +1,495 @@
+# bundlp
+
+> Bun-native TypeScript library for extracting YouTube video and audio streams
+
+[![E2E Tests](https://img.shields.io/badge/E2E%20Tests-100%25%20PASS-brightgreen)]()
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.7-blue)]()
+[![Bun](https://img.shields.io/badge/Bun-1.0+-black)]()
+[![License](https://img.shields.io/badge/License-MIT-yellow)]()
+
+## Features
+
+- **Complete Extraction**: Video, audio, and combined formats with full metadata
+- **Multi-Client Support**: ANDROID_SDKLESS, TV, WEB, IOS with automatic fallback
+- **PO Token System**: Superior implementation with SQLite caching (12h TTL)
+- **AST-Based Cipher**: Signature decryption using meriyah parser
+- **Result Pattern**: Type-safe error handling with `Result<T, E>`
+- **ArkType Validation**: Runtime type validation for API responses
+- **HLS/DASH Support**: Manifest parsing for streaming formats
+- **Zero Python**: Pure TypeScript, optimized for Bun runtime
+
+## Installation
+
+```bash
+bun add bundlp
+```
+
+## Quick Start
+
+```typescript
+import { YouTubeExtractor, isOk } from 'bundlp';
+
+const extractor = new YouTubeExtractor();
+
+// Extract from URL
+const result = await extractor.extract('https://youtube.com/watch?v=dQw4w9WgXcQ');
+
+if (isOk(result)) {
+  const video = result.value;
+
+  console.log('Title:', video.title);
+  console.log('Duration:', video.duration, 'seconds');
+  console.log('Channel:', video.channel.name);
+
+  // Get best audio
+  const bestAudio = video.formats.audio[0];
+  console.log('Best Audio URL:', bestAudio.url);
+  console.log('Audio Quality:', bestAudio.audioQuality);
+  console.log('Sample Rate:', bestAudio.audioSampleRate);
+
+  // Get best video
+  const bestVideo = video.formats.video[0];
+  console.log('Best Video URL:', bestVideo.url);
+  console.log('Resolution:', bestVideo.qualityLabel);
+}
+```
+
+## API Reference
+
+### YouTubeExtractor
+
+Main class for extracting video information.
+
+```typescript
+import { YouTubeExtractor } from 'bundlp';
+
+const extractor = new YouTubeExtractor({
+  cacheDir: '.cache',                  // Optional: cache directory for player.js
+  preferredClient: 'ANDROID_SDKLESS',  // Optional: preferred InnerTube client
+  poToken: 'your-token'                // Optional: static PO token
+});
+```
+
+#### Methods
+
+##### `extract(url: string): Promise<Result<VideoInfo, BundlpError>>`
+
+Extracts complete video information from a YouTube URL or video ID.
+
+**Supported URL formats:**
+- `https://youtube.com/watch?v=VIDEO_ID`
+- `https://youtu.be/VIDEO_ID`
+- `https://youtube.com/shorts/VIDEO_ID`
+- `https://youtube.com/embed/VIDEO_ID`
+- `https://youtube.com/live/VIDEO_ID`
+- `https://music.youtube.com/watch?v=VIDEO_ID`
+- Direct video ID: `dQw4w9WgXcQ`
+
+### VideoInfo
+
+Complete video information returned by `extract()`.
+
+```typescript
+interface VideoInfo {
+  id: string;                    // Video ID
+  title: string;                 // Video title
+  description: string;           // Video description
+  duration: number;              // Duration in seconds
+  uploadDate?: string;           // ISO date string
+  channel: ChannelInfo;          // Channel information
+  viewCount: number;             // View count
+  thumbnails: Thumbnail[];       // Available thumbnails
+  formats: FormatCollection;     // All available formats
+  subtitles: Map<string, Subtitle[]>;  // Subtitles by language
+  isLive: boolean;               // Is live stream
+  isPrivate: boolean;            // Is private video
+}
+```
+
+### FormatCollection
+
+Categorized formats for easy access.
+
+```typescript
+interface FormatCollection {
+  combined: Format[];    // Video+Audio (progressive downloads)
+  video: Format[];       // Video-only (adaptive streaming)
+  audio: Format[];       // Audio-only (adaptive streaming)
+  hls?: HlsInfo;         // HLS manifest info
+  dash?: DashInfo;       // DASH manifest info
+}
+```
+
+### Format
+
+Individual format details.
+
+```typescript
+interface Format {
+  itag: number;              // YouTube format identifier
+  url: string;               // Direct playback URL
+  mimeType: string;          // MIME type (e.g., 'audio/webm')
+  codecs: string[];          // Codec list ['opus']
+  bitrate?: number;          // Bitrate in bps
+
+  // Video properties
+  width?: number;            // Video width
+  height?: number;           // Video height
+  fps?: number;              // Frames per second
+  qualityLabel?: string;     // e.g., '1080p60'
+
+  // Audio properties
+  audioQuality?: string;     // 'AUDIO_QUALITY_LOW/MEDIUM/HIGH'
+  audioSampleRate?: number;  // Sample rate in Hz
+  audioChannels?: number;    // Number of audio channels
+
+  // Metadata
+  contentLength?: number;    // File size in bytes
+  approxDurationMs?: number; // Duration in milliseconds
+  hasDrm: boolean;           // Has DRM protection
+  isAdaptive: boolean;       // Is adaptive format
+}
+```
+
+## Usage Examples
+
+### Get Best Audio URL
+
+```typescript
+import { YouTubeExtractor, isOk } from 'bundlp';
+
+async function getBestAudioUrl(videoUrl: string): Promise<string | null> {
+  const extractor = new YouTubeExtractor();
+  const result = await extractor.extract(videoUrl);
+
+  if (!isOk(result)) {
+    console.error('Extraction failed:', result.error.message);
+    return null;
+  }
+
+  const { audio } = result.value.formats;
+
+  if (audio.length === 0) {
+    console.error('No audio formats available');
+    return null;
+  }
+
+  // Formats are sorted by quality (best first)
+  return audio[0].url;
+}
+
+const audioUrl = await getBestAudioUrl('https://youtube.com/watch?v=dQw4w9WgXcQ');
+console.log('Audio URL:', audioUrl);
+```
+
+### Get All Audio Formats with Details
+
+```typescript
+import { YouTubeExtractor, isOk } from 'bundlp';
+
+async function getAudioFormats(videoUrl: string) {
+  const extractor = new YouTubeExtractor();
+  const result = await extractor.extract(videoUrl);
+
+  if (!isOk(result)) return [];
+
+  return result.value.formats.audio.map(format => ({
+    itag: format.itag,
+    url: format.url,
+    mimeType: format.mimeType,
+    codecs: format.codecs.join(', '),
+    bitrate: format.bitrate ? `${Math.round(format.bitrate / 1000)} kbps` : 'unknown',
+    sampleRate: format.audioSampleRate ? `${format.audioSampleRate} Hz` : 'unknown',
+    channels: format.audioChannels || 2,
+    quality: format.audioQuality || 'unknown',
+    size: format.contentLength
+      ? `${(format.contentLength / 1024 / 1024).toFixed(2)} MB`
+      : 'unknown'
+  }));
+}
+
+const formats = await getAudioFormats('https://youtube.com/watch?v=dQw4w9WgXcQ');
+console.table(formats);
+```
+
+### Get Video Metadata
+
+```typescript
+import { YouTubeExtractor, isOk } from 'bundlp';
+
+async function getVideoMetadata(videoUrl: string) {
+  const extractor = new YouTubeExtractor();
+  const result = await extractor.extract(videoUrl);
+
+  if (!isOk(result)) {
+    throw new Error(result.error.message);
+  }
+
+  const video = result.value;
+
+  return {
+    id: video.id,
+    title: video.title,
+    description: video.description,
+    duration: {
+      seconds: video.duration,
+      formatted: formatDuration(video.duration)
+    },
+    channel: {
+      name: video.channel.name,
+      id: video.channel.id,
+      url: video.channel.url
+    },
+    statistics: {
+      views: video.viewCount,
+      viewsFormatted: formatNumber(video.viewCount)
+    },
+    thumbnails: video.thumbnails.map(t => ({
+      url: t.url,
+      resolution: `${t.width}x${t.height}`
+    })),
+    uploadDate: video.uploadDate,
+    isLive: video.isLive,
+    availableFormats: {
+      video: video.formats.video.length,
+      audio: video.formats.audio.length,
+      combined: video.formats.combined.length
+    }
+  };
+}
+
+function formatDuration(seconds: number): string {
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  const s = seconds % 60;
+  if (h > 0) return `${h}:${m.toString().padStart(2, '0')}:${s.toString().padStart(2, '0')}`;
+  return `${m}:${s.toString().padStart(2, '0')}`;
+}
+
+function formatNumber(num: number): string {
+  if (num >= 1e9) return `${(num / 1e9).toFixed(1)}B`;
+  if (num >= 1e6) return `${(num / 1e6).toFixed(1)}M`;
+  if (num >= 1e3) return `${(num / 1e3).toFixed(1)}K`;
+  return num.toString();
+}
+
+const metadata = await getVideoMetadata('https://youtube.com/watch?v=dQw4w9WgXcQ');
+console.log(JSON.stringify(metadata, null, 2));
+```
+
+### Download Best Quality Audio
+
+```typescript
+import { YouTubeExtractor, isOk } from 'bundlp';
+
+async function downloadAudio(videoUrl: string, outputPath: string) {
+  const extractor = new YouTubeExtractor();
+  const result = await extractor.extract(videoUrl);
+
+  if (!isOk(result)) {
+    throw new Error(`Extraction failed: ${result.error.message}`);
+  }
+
+  const bestAudio = result.value.formats.audio[0];
+
+  if (!bestAudio) {
+    throw new Error('No audio formats available');
+  }
+
+  console.log(`Downloading: ${result.value.title}`);
+  console.log(`Format: ${bestAudio.mimeType} (${bestAudio.codecs.join(', ')})`);
+  console.log(`Bitrate: ${Math.round((bestAudio.bitrate || 0) / 1000)} kbps`);
+
+  const response = await fetch(bestAudio.url);
+  const buffer = await response.arrayBuffer();
+
+  await Bun.write(outputPath, buffer);
+  console.log(`Saved to: ${outputPath}`);
+}
+
+await downloadAudio(
+  'https://youtube.com/watch?v=dQw4w9WgXcQ',
+  'audio.webm'
+);
+```
+
+### Get HLS/DASH Streaming URLs
+
+```typescript
+import { YouTubeExtractor, isOk } from 'bundlp';
+
+async function getStreamingManifests(videoUrl: string) {
+  const extractor = new YouTubeExtractor();
+  const result = await extractor.extract(videoUrl);
+
+  if (!isOk(result)) return null;
+
+  const { hls, dash } = result.value.formats;
+
+  return {
+    hls: hls ? {
+      manifestUrl: hls.manifestUrl,
+      variants: hls.variants.map(v => ({
+        url: v.url,
+        bandwidth: `${Math.round(v.bandwidth / 1000)} kbps`,
+        resolution: v.resolution,
+        codecs: v.codecs
+      }))
+    } : null,
+    dash: dash ? {
+      manifestUrl: dash.manifestUrl,
+      duration: dash.duration
+    } : null
+  };
+}
+
+const manifests = await getStreamingManifests('https://youtube.com/watch?v=dQw4w9WgXcQ');
+console.log(JSON.stringify(manifests, null, 2));
+```
+
+### Filter Formats by Criteria
+
+```typescript
+import { YouTubeExtractor, isOk, type Format } from 'bundlp';
+
+async function getFormatsFiltered(videoUrl: string, options: {
+  maxBitrate?: number;
+  codec?: string;
+  minQuality?: string;
+}) {
+  const extractor = new YouTubeExtractor();
+  const result = await extractor.extract(videoUrl);
+
+  if (!isOk(result)) return { audio: [], video: [] };
+
+  const { audio, video } = result.value.formats;
+
+  const filterFormat = (f: Format) => {
+    if (options.maxBitrate && f.bitrate && f.bitrate > options.maxBitrate) return false;
+    if (options.codec && !f.codecs.some(c => c.includes(options.codec!))) return false;
+    return true;
+  };
+
+  return {
+    audio: audio.filter(filterFormat),
+    video: video.filter(filterFormat)
+  };
+}
+
+// Get only opus audio under 128kbps
+const formats = await getFormatsFiltered('https://youtube.com/watch?v=dQw4w9WgXcQ', {
+  codec: 'opus',
+  maxBitrate: 128000
+});
+```
+
+## Result Pattern
+
+bundlp uses the Result pattern for type-safe error handling.
+
+```typescript
+import { isOk, isErr, match, unwrapOr } from 'bundlp';
+
+// Check result type
+if (isOk(result)) {
+  console.log(result.value);
+} else {
+  console.error(result.error);
+}
+
+// Pattern matching
+match(result, {
+  ok: (video) => console.log('Success:', video.title),
+  err: (error) => console.error('Error:', error.message)
+});
+
+// Default value on error
+const video = unwrapOr(result, defaultVideoInfo);
+```
+
+## Error Codes
+
+| Code | Description |
+|------|-------------|
+| `INVALID_URL` | Could not parse video ID from URL |
+| `VIDEO_UNAVAILABLE` | Video is unavailable or deleted |
+| `NETWORK_ERROR` | Network request failed |
+| `PARSE_ERROR` | Failed to parse response |
+| `CIPHER_ERROR` | Signature decryption failed |
+| `ALL_CLIENTS_FAILED` | All InnerTube clients failed |
+
+## CLI
+
+bundlp includes a CLI for testing and debugging.
+
+```bash
+# Extract video info
+bun run cli extract https://youtube.com/watch?v=dQw4w9WgXcQ
+
+# List formats
+bun run cli formats https://youtube.com/watch?v=dQw4w9WgXcQ
+
+# Debug extraction
+bun run cli debug https://youtube.com/watch?v=dQw4w9WgXcQ
+
+# Run benchmarks
+bun run cli benchmark
+```
+
+## Performance
+
+| Operation | Time (cached) | Time (fresh) |
+|-----------|---------------|--------------|
+| Full Extraction | ~130ms | ~5s |
+| Player.js Parse | ~20ms | ~5s |
+| PO Token | ~10ms | ~800ms |
+| InnerTube Request | ~120ms | ~120ms |
+
+## Architecture
+
+```
+src/
+├── core/           # YouTubeExtractor
+├── innertube/      # InnerTube API client
+├── player/         # Player.js + AST cipher extraction
+├── streaming/      # HLS/DASH processing
+├── po-token/       # PO Token system
+├── http/           # HTTP client with cookies
+├── result/         # Result<T,E> pattern
+├── types/          # TypeScript types
+├── validation/     # ArkType schemas
+└── utils/          # Constants, parsers
+```
+
+## Documentation
+
+- [API Reference](./docs/API-REFERENCE.md) - Complete API documentation
+- [Examples](./docs/EXAMPLES.md) - More usage examples
+- [Architecture](./ARCHITECTURE.md) - Technical architecture
+- [Status](./docs/STATUS.md) - Current status and comparisons
+
+## Development
+
+```bash
+# Install dependencies
+bun install
+
+# Run E2E tests
+bun test:e2e
+
+# Run unit tests
+bun test
+
+# Type check
+bunx tsc --noEmit
+
+# Lint
+bun run lint
+
+# CLI
+bun run cli
+```
+
+## License
+
+MIT

package/dist/core/extractor.d.ts

@@ -0,0 +1,30 @@
+import { type Result } from '../result';
+import type { VideoInfo } from '../types/video.types';
+import { type BundlpError } from '../types/error.types';
+import type { ClientName } from '../utils/constants';
+export interface ExtractorConfig {
+    poToken?: string;
+    cacheDir?: string;
+    preferredClient?: ClientName;
+}
+/**
+ * Main YouTube video extractor class.
+ * Handles video information extraction using InnerTube API.
+ */
+export declare class YouTubeExtractor {
+    private client;
+    private player;
+    private config;
+    constructor(config?: ExtractorConfig);
+    /**
+     * Extracts video information from a YouTube URL or video ID.
+     * @param url - YouTube URL or video ID
+     * @returns Result containing VideoInfo or BundlpError
+     */
+    extract(url: string): Promise<Result<VideoInfo, BundlpError>>;
+    private parseVideoId;
+    private realExtract;
+    private processFormats;
+    private assembleVideoInfo;
+}
+//# sourceMappingURL=extractor.d.ts.map

package/dist/core/extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractor.d.ts","sourceRoot":"","sources":["../../src/core/extractor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,MAAM,EAAS,MAAM,WAAW,CAAC;AAIxD,OAAO,KAAK,EAAE,SAAS,EAAoB,MAAM,sBAAsB,CAAC;AACxE,OAAO,EAAe,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAKrD,MAAM,WAAW,eAAe;IAC5B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,eAAe,CAAC,EAAE,UAAU,CAAC;CAChC;AAaD;;;GAGG;AACH,qBAAa,gBAAgB;IACzB,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,MAAM,CAAkB;gBAEpB,MAAM,GAAE,eAAoB;IAMxC;;;;OAIG;IACG,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;IAgBnE,OAAO,CAAC,YAAY;YAcN,WAAW;YAyBX,cAAc;IAK5B,OAAO,CAAC,iBAAiB;CA2B5B"}

package/dist/http/client.d.ts

@@ -0,0 +1,50 @@
+import { type Result } from '../result';
+import type { BundlpError } from '../types/error.types';
+export interface HttpClientOptions extends RequestInit {
+    timeout?: number;
+    maxRedirects?: number;
+    manualRedirects?: boolean;
+}
+interface Cookie {
+    name: string;
+    value: string;
+    domain?: string;
+    path?: string;
+    expires?: Date;
+    secure?: boolean;
+    httpOnly?: boolean;
+}
+/**
+ * HTTP client with cookie jar and controlled redirect handling.
+ * Superior to YouTube.js: tracks cookies across redirects, prevents loops.
+ */
+export declare class HttpClient {
+    private cookies;
+    /**
+     * Performs a fetch request with automatic cookie and redirect handling.
+     * @param url - The URL to fetch
+     * @param options - Fetch options. Use manualRedirects=true for controlled redirects
+     * @returns Result containing the Response or a BundlpError
+     */
+    request(url: string, options?: HttpClientOptions): Promise<Result<Response, BundlpError>>;
+    clearCookies(): void;
+    getCookies(): Map<string, Cookie>;
+    /**
+     * Performs a GET request.
+     * @param url - The URL to fetch
+     * @param options - Optional fetch options
+     * @returns Result containing the Response or a BundlpError
+     */
+    get(url: string, options?: HttpClientOptions): Promise<Result<Response, BundlpError>>;
+    /**
+     * Performs a POST request with JSON body.
+     * @param url - The URL to post to
+     * @param body - The request body (will be JSON stringified)
+     * @param options - Optional fetch options
+     * @returns Result containing the Response or a BundlpError
+     */
+    post(url: string, body: unknown, options?: HttpClientOptions): Promise<Result<Response, BundlpError>>;
+}
+export declare const httpClient: HttpClient;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/http/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/http/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,WAAW,CAAC;AACjD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAGxD,MAAM,WAAW,iBAAkB,SAAQ,WAAW;IAClD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,UAAU,MAAM;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,IAAI,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB;AA8BD;;;GAGG;AACH,qBAAa,UAAU;IACnB,OAAO,CAAC,OAAO,CAAkC;IAEjD;;;;;OAKG;IACG,OAAO,CACT,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,iBAAsB,GAChC,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;IAkFzC,YAAY,IAAI,IAAI;IAIpB,UAAU,IAAI,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC;IAIjC;;;;;OAKG;IACG,GAAG,CACL,GAAG,EAAE,MAAM,EACX,OAAO,GAAE,iBAAsB,GAChC,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;IAIzC;;;;;;OAMG;IACG,IAAI,CACN,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,OAAO,EACb,OAAO,GAAE,iBAAsB,GAChC,OAAO,CAAC,MAAM,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;CAW5C;AAED,eAAO,MAAM,UAAU,YAAmB,CAAC"}

package/dist/http/retry.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Retry utilities with exponential backoff.
+ * Provides automatic retry logic for transient failures.
+ * @module http/retry
+ */
+export interface RetryOptions {
+    retries?: number;
+    delay?: number;
+    backoff?: number;
+    maxDelay?: number;
+    shouldRetry?: (error: Error) => boolean;
+    onRetry?: (error: Error, attempt: number) => void;
+}
+/**
+ * Executes a function with automatic retry on failure.
+ * @param fn - The async function to execute
+ * @param options - Retry configuration options
+ * @returns The result of the function if successful
+ * @throws The last error if all retries are exhausted
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+//# sourceMappingURL=retry.d.ts.map

package/dist/http/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/http/retry.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,MAAM,WAAW,YAAY;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC;IACxC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACrD;AAID;;;;;;GAMG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAC7B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,OAAO,GAAE,YAAiB,GAC3B,OAAO,CAAC,CAAC,CAAC,CA2BZ"}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * bundlp - Bun-native YouTube video/music resolver
+ *
+ * @example
+ * ```typescript
+ * import { YouTubeExtractor, isOk } from 'bundlp';
+ *
+ * const extractor = new YouTubeExtractor();
+ * const result = await extractor.extract('https://youtube.com/watch?v=dQw4w9WgXcQ');
+ *
+ * if (isOk(result)) {
+ *   console.log(result.value.title);
+ *   console.log(result.value.formats.video);
+ * }
+ * ```
+ */
+export { type Result, type ResultOk, type ResultErr, ok, err, isOk, isErr, match, map, mapErr, andThen, unwrapOr, unwrap, tryCatch, tryCatchAsync, } from './result';
+export type { VideoInfo, ChannelInfo, Thumbnail, FormatCollection, Format, AudioFormat, VideoFormat, HlsInfo, HlsVariant, DashInfo, Subtitle, Chapter, Storyboard, ErrorCode, BundlpError, ClientName, ClientConfig, InnerTubeContext, PlayerResponse, StreamingData, PlayerInfo, SignatureCipher, } from './types';
+export { YouTubeExtractor, type ExtractorConfig } from './core/extractor';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EACL,KAAK,MAAM,EACX,KAAK,QAAQ,EACb,KAAK,SAAS,EACd,EAAE,EACF,GAAG,EACH,IAAI,EACJ,KAAK,EACL,KAAK,EACL,GAAG,EACH,MAAM,EACN,OAAO,EACP,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,aAAa,GACd,MAAM,UAAU,CAAC;AAGlB,YAAY,EAEV,SAAS,EACT,WAAW,EACX,SAAS,EACT,gBAAgB,EAChB,MAAM,EACN,WAAW,EACX,WAAW,EACX,OAAO,EACP,UAAU,EACV,QAAQ,EACR,QAAQ,EACR,OAAO,EACP,UAAU,EAEV,SAAS,EACT,WAAW,EAEX,UAAU,EACV,YAAY,EACZ,gBAAgB,EAChB,cAAc,EACd,aAAa,EAEb,UAAU,EACV,eAAe,GAChB,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,gBAAgB,EAAE,KAAK,eAAe,EAAE,MAAM,kBAAkB,CAAC"}