youtube-transcript-plus 1.0.0

package/README.md

@@ -0,0 +1,213 @@
+# youtube-transcript-plus
+
+[![npm version](https://badge.fury.io/js/youtube-transcript-plus.svg)](https://badge.fury.io/js/youtube-transcript-plus)
+
+A Node.js library to fetch transcripts from YouTube videos. This package uses YouTube's unofficial API, so it may break if YouTube changes its internal structure.
+
+**Note:** This project was originally forked from [https://github.com/Kakulukian/youtube-transcript](https://github.com/Kakulukian/youtube-transcript).
+
+## Installation
+
+```bash
+$ npm install youtube-transcript-plus
+```
+
+or
+
+```bash
+$ yarn add youtube-transcript-plus
+```
+
+## Usage
+
+### Basic Usage
+
+```javascript
+import { fetchTranscript } from 'youtube-transcript-plus';
+
+// Fetch transcript using default settings
+fetchTranscript('videoId_or_URL').then(console.log).catch(console.error);
+```
+
+### Custom User-Agent
+
+You can pass a custom `userAgent` string to mimic different browsers or devices.
+
+```javascript
+fetchTranscript('videoId_or_URL', {
+  userAgent:
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
+})
+  .then(console.log)
+  .catch(console.error);
+```
+
+### Custom Fetch Functions
+
+You can inject custom `videoFetch` and `transcriptFetch` functions to modify the fetch behavior, such as using a proxy or custom headers.
+
+```javascript
+fetchTranscript('videoId_or_URL', {
+  videoFetch: async ({ url, lang, userAgent }) => {
+    return fetch(`https://my-proxy-server.com/?url=${encodeURIComponent(url)}`, {
+      headers: {
+        ...(lang && { 'Accept-Language': lang }),
+        'User-Agent': userAgent,
+      },
+    });
+  },
+  transcriptFetch: async ({ url, lang, userAgent }) => {
+    return fetch(`https://my-proxy-server.com/?url=${encodeURIComponent(url)}`, {
+      headers: {
+        ...(lang && { 'Accept-Language': lang }),
+        'User-Agent': userAgent,
+      },
+    });
+  },
+})
+  .then(console.log)
+  .catch(console.error);
+```
+
+### Language Support
+
+You can specify the language for the transcript using the `lang` option.
+
+```javascript
+fetchTranscript('videoId_or_URL', {
+  lang: 'fr', // Fetch transcript in French
+})
+  .then(console.log)
+  .catch(console.error);
+```
+
+### Caching
+
+You can provide a custom caching strategy by implementing the `CacheStrategy` interface. The library also provides default implementations for in-memory and file system caching.
+
+#### In-Memory Cache
+
+```typescript
+import { fetchTranscript, InMemoryCache } from 'youtube-transcript-plus';
+
+fetchTranscript('videoId_or_URL', {
+  lang: 'en',
+  userAgent: 'FOO',
+  cache: new InMemoryCache(1800000), // 30 minutes TTL
+})
+  .then(console.log)
+  .catch(console.error);
+```
+
+#### File System Cache
+
+```typescript
+import { fetchTranscript, FsCache } from 'youtube-transcript-plus';
+
+fetchTranscript('videoId_or_URL', {
+  cache: new FsCache('./my-cache-dir', 86400000), // 1 day TTL
+})
+  .then(console.log)
+  .catch(console.error);
+```
+
+### Custom Caching
+
+If the default implementations don’t meet your needs, you can implement your own caching strategy:
+
+```typescript
+import { fetchTranscript, CacheStrategy } from 'youtube-transcript-plus';
+
+class CustomCache implements CacheStrategy {
+  async get(key: string): Promise<string | null> {
+    // Custom logic
+  }
+
+  async set(key: string, value: string, ttl?: number): Promise<void> {
+    // Custom logic
+  }
+}
+
+fetchTranscript('videoId_or_URL', {
+  cache: new CustomCache(),
+})
+  .then(console.log)
+  .catch(console.error);
+```
+
+### Error Handling
+
+The library throws specific errors for different failure scenarios. Make sure to handle them appropriately.
+
+```javascript
+import {
+  YoutubeTranscriptVideoUnavailableError,
+  YoutubeTranscriptDisabledError,
+  YoutubeTranscriptNotAvailableError,
+  YoutubeTranscriptNotAvailableLanguageError,
+} from 'youtube-transcript-plus';
+
+fetchTranscript('videoId_or_URL')
+  .then(console.log)
+  .catch((error) => {
+    if (error instanceof YoutubeTranscriptVideoUnavailableError) {
+      console.error('Video is unavailable:', error.message);
+    } else if (error instanceof YoutubeTranscriptDisabledError) {
+      console.error('Transcripts are disabled for this video:', error.message);
+    } else if (error instanceof YoutubeTranscriptNotAvailableError) {
+      console.error('No transcript available:', error.message);
+    } else if (error instanceof YoutubeTranscriptNotAvailableLanguageError) {
+      console.error('Transcript not available in the specified language:', error.message);
+    } else {
+      console.error('An unexpected error occurred:', error.message);
+    }
+  });
+```
+
+### Example Usage Files
+
+The repository includes several example files in the `example/` directory to demonstrate different use cases of the library:
+
+1. **`basic-usage.js`**: Demonstrates the simplest way to fetch a transcript using the default settings.
+2. **`caching-usage.js`**: Shows how to use the `InMemoryCache` to cache transcripts with a 30-minute TTL.
+3. **`fs-caching-usage.js`**: Demonstrates how to use the `FsCache` to cache transcripts on the file system with a 1-day TTL.
+4. **`language-usage.js`**: Shows how to fetch a transcript in a specific language (e.g., French).
+5. **`proxy-usage.js`**: Demonstrates how to use a proxy server to fetch transcripts, which can be useful for bypassing rate limits or accessing restricted content.
+
+These examples can be found in the `example/` directory of the repository.
+
+### API
+
+### `fetchTranscript(videoId: string, config?: TranscriptConfig)`
+
+Fetches the transcript for a YouTube video.
+
+- **`videoId`**: The YouTube video ID or URL.
+- **`config`**: Optional configuration object with the following properties:
+  - **`lang`**: Language code (e.g., `'en'`, `'fr'`) for the transcript.
+  - **`userAgent`**: Custom User-Agent string.
+  - **`cache`**: Custom caching strategy.
+  - **`cacheTTL`**: Time-to-live for cache entries in milliseconds.
+  - **`videoFetch`**: Custom fetch function for the video page request.
+  - **`transcriptFetch`**: Custom fetch function for the transcript request.
+
+Returns a `Promise<TranscriptResponse[]>` where each item in the array represents a transcript segment with the following properties:
+
+- **`text`**: The text of the transcript segment.
+- **`duration`**: The duration of the segment in seconds.
+- **`offset`**: The start time of the segment in seconds.
+- **`lang`**: The language of the transcript.
+
+## Errors
+
+The library throws the following errors:
+
+- **`YoutubeTranscriptVideoUnavailableError`**: The video is unavailable or has been removed.
+- **`YoutubeTranscriptDisabledError`**: Transcripts are disabled for the video.
+- **`YoutubeTranscriptNotAvailableError`**: No transcript is available for the video.
+- **`YoutubeTranscriptNotAvailableLanguageError`**: The transcript is not available in the specified language.
+- **`YoutubeTranscriptInvalidVideoIdError`**: The provided video ID or URL is invalid.
+
+## License
+
+**[MIT](LICENSE)** Licensed

package/dist/cache/fs-cache.d.ts

@@ -0,0 +1,8 @@
+import { CacheStrategy } from '../types';
+export declare class FsCache implements CacheStrategy {
+    private cacheDir;
+    private defaultTTL;
+    constructor(cacheDir?: string, defaultTTL?: number);
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, ttl?: number): Promise<void>;
+}

package/dist/cache/in-memory-cache.d.ts

@@ -0,0 +1,8 @@
+import { CacheStrategy } from '../types';
+export declare class InMemoryCache implements CacheStrategy {
+    private cache;
+    private defaultTTL;
+    constructor(defaultTTL?: number);
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, ttl?: number): Promise<void>;
+}

package/dist/cache/index.d.ts

@@ -0,0 +1,2 @@
+export * from './fs-cache';
+export * from './in-memory-cache';

package/dist/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_USER_AGENT = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36";
+export declare const RE_YOUTUBE: RegExp;
+export declare const RE_XML_TRANSCRIPT: RegExp;

package/dist/errors.d.ts

@@ -0,0 +1,18 @@
+export declare class YoutubeTranscriptTooManyRequestError extends Error {
+    constructor();
+}
+export declare class YoutubeTranscriptVideoUnavailableError extends Error {
+    constructor(videoId: string);
+}
+export declare class YoutubeTranscriptDisabledError extends Error {
+    constructor(videoId: string);
+}
+export declare class YoutubeTranscriptNotAvailableError extends Error {
+    constructor(videoId: string);
+}
+export declare class YoutubeTranscriptNotAvailableLanguageError extends Error {
+    constructor(lang: string, availableLangs: string[], videoId: string);
+}
+export declare class YoutubeTranscriptInvalidVideoIdError extends Error {
+    constructor();
+}

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { TranscriptConfig, TranscriptResponse } from './types';
+export declare class YoutubeTranscript {
+    private config?;
+    constructor(config?: TranscriptConfig & {
+        cacheTTL?: number;
+    });
+    fetchTranscript(videoId: string): Promise<TranscriptResponse[]>;
+    static fetchTranscript(videoId: string, config?: TranscriptConfig): Promise<TranscriptResponse[]>;
+}
+export type { CacheStrategy } from './types';
+export { InMemoryCache, FsCache } from './cache';
+export declare const fetchTranscript: typeof YoutubeTranscript.fetchTranscript;

package/dist/types.d.ts

@@ -0,0 +1,26 @@
+export interface CacheStrategy {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, ttl?: number): Promise<void>;
+}
+export interface TranscriptConfig {
+    lang?: string;
+    userAgent?: string;
+    cache?: CacheStrategy;
+    cacheTTL?: number;
+    videoFetch?: (params: {
+        url: string;
+        lang?: string;
+        userAgent?: string;
+    }) => Promise<Response>;
+    transcriptFetch?: (params: {
+        url: string;
+        lang?: string;
+        userAgent?: string;
+    }) => Promise<Response>;
+}
+export interface TranscriptResponse {
+    text: string;
+    duration: number;
+    offset: number;
+    lang?: string;
+}

package/dist/utils.d.ts

@@ -0,0 +1,6 @@
+export declare function retrieveVideoId(videoId: string): string;
+export declare function defaultFetch({ url, lang, userAgent, }: {
+    url: string;
+    lang?: string;
+    userAgent?: string;
+}): Promise<Response>;

package/dist/youtube-transcript-plus.js

@@ -0,0 +1,250 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const DEFAULT_USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36';
+const RE_YOUTUBE = /(?:youtube\.com\/(?:[^\/]+\/.+\/|(?:v|e(?:mbed)?)\/|.*[?&]v=)|youtu\.be\/)([^"&?\/\s]{11})/i;
+const RE_XML_TRANSCRIPT = /<text start="([^"]*)" dur="([^"]*)">([^<]*)<\/text>/g;
+
+class YoutubeTranscriptTooManyRequestError extends Error {
+    constructor() {
+        super('YouTube is receiving too many requests from your IP address. Please try again later or use a proxy. If the issue persists, consider reducing the frequency of requests.');
+        this.name = 'YoutubeTranscriptTooManyRequestError';
+    }
+}
+class YoutubeTranscriptVideoUnavailableError extends Error {
+    constructor(videoId) {
+        super(`The video with ID "${videoId}" is no longer available or has been removed. Please check the video URL or ID and try again.`);
+        this.name = 'YoutubeTranscriptVideoUnavailableError';
+    }
+}
+class YoutubeTranscriptDisabledError extends Error {
+    constructor(videoId) {
+        super(`Transcripts are disabled for the video with ID "${videoId}". This may be due to the video owner disabling captions or the video not supporting transcripts.`);
+        this.name = 'YoutubeTranscriptDisabledError';
+    }
+}
+class YoutubeTranscriptNotAvailableError extends Error {
+    constructor(videoId) {
+        super(`No transcripts are available for the video with ID "${videoId}". This may be because the video does not have captions or the captions are not accessible.`);
+        this.name = 'YoutubeTranscriptNotAvailableError';
+    }
+}
+class YoutubeTranscriptNotAvailableLanguageError extends Error {
+    constructor(lang, availableLangs, videoId) {
+        super(`No transcripts are available in "${lang}" for the video with ID "${videoId}". Available languages: ${availableLangs.join(', ')}. Please try a different language.`);
+        this.name = 'YoutubeTranscriptNotAvailableLanguageError';
+    }
+}
+class YoutubeTranscriptInvalidVideoIdError extends Error {
+    constructor() {
+        super('Invalid YouTube video ID or URL. Please provide a valid video ID or URL. Example: "dQw4w9WgXcQ" or "https://www.youtube.com/watch?v=dQw4w9WgXcQ".');
+        this.name = 'YoutubeTranscriptInvalidVideoIdError';
+    }
+}
+
+function retrieveVideoId(videoId) {
+    if (videoId.length === 11) {
+        return videoId;
+    }
+    const matchId = videoId.match(RE_YOUTUBE);
+    if (matchId && matchId.length) {
+        return matchId[1];
+    }
+    throw new YoutubeTranscriptInvalidVideoIdError();
+}
+function defaultFetch(_a) {
+    return __awaiter(this, arguments, undefined, function* ({ url, lang, userAgent, }) {
+        return fetch(url, {
+            headers: Object.assign(Object.assign({}, (lang && { 'Accept-Language': lang })), { 'User-Agent': userAgent || DEFAULT_USER_AGENT }),
+        });
+    });
+}
+
+class FsCache {
+    constructor(cacheDir = './cache', defaultTTL = 3600000) {
+        this.cacheDir = cacheDir;
+        this.defaultTTL = defaultTTL;
+        fs.mkdir(cacheDir, { recursive: true }).catch(() => { });
+    }
+    get(key) {
+        return __awaiter(this, undefined, undefined, function* () {
+            const filePath = path.join(this.cacheDir, key);
+            try {
+                const data = yield fs.readFile(filePath, 'utf-8');
+                const { value, expires } = JSON.parse(data);
+                if (expires > Date.now()) {
+                    return value;
+                }
+                yield fs.unlink(filePath);
+            }
+            catch (error) { }
+            return null;
+        });
+    }
+    set(key, value, ttl) {
+        return __awaiter(this, undefined, undefined, function* () {
+            const filePath = path.join(this.cacheDir, key);
+            const expires = Date.now() + (ttl !== null && ttl !== undefined ? ttl : this.defaultTTL);
+            yield fs.writeFile(filePath, JSON.stringify({ value, expires }), 'utf-8');
+        });
+    }
+}
+
+class InMemoryCache {
+    constructor(defaultTTL = 3600000) {
+        this.cache = new Map();
+        // 1 hour default TTL
+        this.defaultTTL = defaultTTL;
+    }
+    get(key) {
+        return __awaiter(this, undefined, undefined, function* () {
+            const entry = this.cache.get(key);
+            if (entry && entry.expires > Date.now()) {
+                return entry.value;
+            }
+            this.cache.delete(key); // Clean up expired entries
+            return null;
+        });
+    }
+    set(key, value, ttl) {
+        return __awaiter(this, undefined, undefined, function* () {
+            const expires = Date.now() + (ttl !== null && ttl !== undefined ? ttl : this.defaultTTL);
+            this.cache.set(key, { value, expires });
+        });
+    }
+}
+
+class YoutubeTranscript {
+    constructor(config) {
+        this.config = config;
+    }
+    fetchTranscript(videoId) {
+        return __awaiter(this, undefined, undefined, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+            const identifier = retrieveVideoId(videoId);
+            const userAgent = ((_a = this.config) === null || _a === undefined ? undefined : _a.userAgent) || DEFAULT_USER_AGENT;
+            // Use custom fetch functions if provided, otherwise use defaultFetch
+            const videoFetch = ((_b = this.config) === null || _b === undefined ? undefined : _b.videoFetch) || defaultFetch;
+            const transcriptFetch = ((_c = this.config) === null || _c === undefined ? undefined : _c.transcriptFetch) || defaultFetch;
+            // Cache key based on video ID and language
+            const cacheKey = `transcript:${identifier}:${((_d = this.config) === null || _d === undefined ? undefined : _d.lang) || 'default'}`;
+            // Check cache first
+            if ((_e = this.config) === null || _e === undefined ? undefined : _e.cache) {
+                const cachedTranscript = yield this.config.cache.get(cacheKey);
+                if (cachedTranscript) {
+                    return JSON.parse(cachedTranscript);
+                }
+            }
+            // Fetch the video page
+            const videoPageResponse = yield videoFetch({
+                url: `https://www.youtube.com/watch?v=${identifier}`,
+                lang: (_f = this.config) === null || _f === undefined ? undefined : _f.lang,
+                userAgent,
+            });
+            if (!videoPageResponse.ok) {
+                throw new YoutubeTranscriptVideoUnavailableError(identifier);
+            }
+            const videoPageBody = yield videoPageResponse.text();
+            // Parse the video page to extract captions
+            const splittedHTML = videoPageBody.split('"captions":');
+            if (splittedHTML.length <= 1) {
+                if (videoPageBody.includes('class="g-recaptcha"')) {
+                    throw new YoutubeTranscriptTooManyRequestError();
+                }
+                if (!videoPageBody.includes('"playabilityStatus":')) {
+                    throw new YoutubeTranscriptVideoUnavailableError(identifier);
+                }
+                throw new YoutubeTranscriptDisabledError(identifier);
+            }
+            const captions = (_g = (() => {
+                try {
+                    return JSON.parse(splittedHTML[1].split(',"videoDetails')[0].replace('\n', ''));
+                }
+                catch (e) {
+                    return undefined;
+                }
+            })()) === null || _g === undefined ? undefined : _g['playerCaptionsTracklistRenderer'];
+            if (!captions) {
+                throw new YoutubeTranscriptDisabledError(identifier);
+            }
+            if (!('captionTracks' in captions)) {
+                throw new YoutubeTranscriptNotAvailableError(identifier);
+            }
+            if (((_h = this.config) === null || _h === undefined ? undefined : _h.lang) &&
+                !captions.captionTracks.some((track) => { var _a; return track.languageCode === ((_a = this.config) === null || _a === undefined ? undefined : _a.lang); })) {
+                throw new YoutubeTranscriptNotAvailableLanguageError((_j = this.config) === null || _j === undefined ? undefined : _j.lang, captions.captionTracks.map((track) => track.languageCode), identifier);
+            }
+            const transcriptURL = (((_k = this.config) === null || _k === undefined ? undefined : _k.lang)
+                ? captions.captionTracks.find((track) => { var _a; return track.languageCode === ((_a = this.config) === null || _a === undefined ? undefined : _a.lang); })
+                : captions.captionTracks[0]).baseUrl;
+            // Fetch the transcript
+            const transcriptResponse = yield transcriptFetch({
+                url: transcriptURL,
+                lang: (_l = this.config) === null || _l === undefined ? undefined : _l.lang,
+                userAgent,
+            });
+            if (!transcriptResponse.ok) {
+                throw new YoutubeTranscriptNotAvailableError(identifier);
+            }
+            const transcriptBody = yield transcriptResponse.text();
+            const results = [...transcriptBody.matchAll(RE_XML_TRANSCRIPT)];
+            const transcript = results.map((result) => {
+                var _a, _b;
+                return ({
+                    text: result[3],
+                    duration: parseFloat(result[2]),
+                    offset: parseFloat(result[1]),
+                    lang: (_b = (_a = this.config) === null || _a === undefined ? undefined : _a.lang) !== null && _b !== undefined ? _b : captions.captionTracks[0].languageCode,
+                });
+            });
+            // Store in cache if a strategy is provided
+            if ((_m = this.config) === null || _m === undefined ? undefined : _m.cache) {
+                yield this.config.cache.set(cacheKey, JSON.stringify(transcript), this.config.cacheTTL);
+            }
+            return transcript;
+        });
+    }
+    // Add static method for new usage pattern
+    static fetchTranscript(videoId, config) {
+        return __awaiter(this, undefined, undefined, function* () {
+            const instance = new YoutubeTranscript(config);
+            return instance.fetchTranscript(videoId);
+        });
+    }
+}
+// Export the static method directly for convenience
+const fetchTranscript = YoutubeTranscript.fetchTranscript;
+
+export { FsCache, InMemoryCache, YoutubeTranscript, fetchTranscript };

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "youtube-transcript-plus",
+  "version": "1.0.0",
+  "description": "Fetch transcript from a youtube video",
+  "type": "module",
+  "main": "dist/youtube-transcript-plus.js",
+  "module": "dist/youtube-transcript-plus.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "rollup -c",
+    "format": "prettier --write 'src/**/*.ts'",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "prepare": "husky install"
+  },
+  "author": "ericmmartin",
+  "keywords": [
+    "youtube",
+    "transcript"
+  ],
+  "license": "MIT",
+  "lint-staged": {
+    "src/**/*.ts": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "*.{js,json,md}": [
+      "prettier --write"
+    ]
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "https-proxy-agent": "^7.0.6",
+    "husky": "^9.1.7",
+    "jest": "^29.7.0",
+    "lint-staged": "^15.3.0",
+    "prettier": "^3.4.2",
+    "rollup": "^4.30.1",
+    "rollup-plugin-typescript": "^1.0.1",
+    "rollup-plugin-typescript2": "^0.36.0",
+    "ts-jest": "^29.2.5",
+    "tslib": "^2.8.1",
+    "typescript": "^5.7.3"
+  },
+  "files": [
+    "dist/*"
+  ],
+  "repository": "https://github.com/ericmmartin/youtube-transcript.git",
+  "publishConfig": {
+    "access": "public"
+  },
+  "homepage": "https://github.com/ericmmartin/youtube-transcript",
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}