youtube-thumbnail-url 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ThumbnailsGrabber (thumbnailsgrabber.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,123 @@
+# youtube-thumbnail-url
+
+Build every YouTube thumbnail URL for a video and resolve the largest one that
+**really exists**. Zero dependencies, ~6 KB, works in Node 18+ and in the browser.
+
+Most snippets on the web do `https://img.youtube.com/vi/ID/maxresdefault.jpg` and
+hope. About 1 in 9 videos has no `maxresdefault`, and when it is missing YouTube
+answers **HTTP 404 with a 120x90 grey JPEG as the body**, so an `<img>` tag still
+"loads" and shows a tiny grey box. This package checks the status *and* the real
+pixel width (from the first 4 KB of the file) before it hands you a URL.
+
+The fallback order and the notes on each size are based on a measurement of
+8,664 public videos, published with a CC BY 4.0 dataset:
+[YouTube Thumbnail Statistics](https://thumbnailsgrabber.com/youtube-thumbnail-statistics).
+The URL patterns themselves are documented in the
+[YouTube Thumbnail URL Guide](https://thumbnailsgrabber.com/youtube-thumbnail-url-guide).
+
+## Install
+
+```sh
+npm install youtube-thumbnail-url
+```
+
+## Usage
+
+```js
+import { thumbnailUrl, thumbnailUrls, resolveThumbnail, getVideoId } from 'youtube-thumbnail-url';
+// CommonJS: const { thumbnailUrl } = require('youtube-thumbnail-url');
+
+getVideoId('https://youtu.be/dQw4w9WgXcQ?si=x');   // 'dQw4w9WgXcQ'
+getVideoId('https://www.youtube.com/shorts/tPEE9ZwTmy0'); // 'tPEE9ZwTmy0'
+
+thumbnailUrl('dQw4w9WgXcQ');
+// 'https://i.ytimg.com/vi/dQw4w9WgXcQ/maxresdefault.jpg'
+
+thumbnailUrl('dQw4w9WgXcQ', 'hqdefault', { format: 'webp' });
+// 'https://i.ytimg.com/vi_webp/dQw4w9WgXcQ/hqdefault.webp'   (about half the bytes)
+
+thumbnailUrls('dQw4w9WgXcQ');
+// { default: { url, width: 120, height: 90 }, mqdefault: {...}, hqdefault: {...},
+//   sddefault: {...}, hq720: {...}, maxresdefault: {...}, oar2: {...} }
+
+// The part that matters: the biggest file that actually exists.
+const best = await resolveThumbnail('https://www.youtube.com/watch?v=tPEE9ZwTmy0');
+// { id: 'tPEE9ZwTmy0', size: 'sddefault', format: 'jpg',
+//   url: 'https://i.ytimg.com/vi/tPEE9ZwTmy0/sddefault.jpg',
+//   width: 640, height: 480, bytes: 55898, status: 206,
+//   checked: [ { size: 'maxresdefault', ok: false, status: 404, ... }, { size: 'sddefault', ok: true, ... } ] }
+```
+
+Prefer the vertical Shorts cover when there is one, WebP when available:
+
+```js
+await resolveThumbnail(id, { order: ['oar2', 'maxresdefault', 'sddefault', 'hqdefault'], format: 'webp' });
+```
+
+Check a single URL:
+
+```js
+import { checkThumbnail } from 'youtube-thumbnail-url';
+await checkThumbnail('https://i.ytimg.com/vi/tPEE9ZwTmy0/maxresdefault.jpg');
+// { ok: false, status: 404, width: null, height: null, bytes: 1097 }
+```
+
+## Sizes
+
+| name            | pixels        | exists for                          |
+| --------------- | ------------- | ----------------------------------- |
+| `default`       | 120 x 90      | 100% of videos                      |
+| `mqdefault`     | 320 x 180     | 100%                                |
+| `hqdefault`     | 480 x 360     | 100% (4:3, black bars)              |
+| `sddefault`     | 640 x 480     | ~96% (4:3, black bars)              |
+| `hq720`         | 1280 x 720    | same file as `maxresdefault`        |
+| `maxresdefault` | 1280 x 720    | ~88% (0% of 2008-09 uploads, 91-95% since 2023) |
+| `oar2`          | 1080 x 1920   | ~30%, the vertical Shorts cover     |
+
+`maxresdefault -> sddefault -> hqdefault` covers 100% of videos, which is why it is
+the default `order`. There is no 4K or 1080p landscape rendition; 1280 x 720 is the
+ceiling for practically every video. Percentages: [study, Sept 2026](https://thumbnailsgrabber.com/youtube-thumbnail-statistics).
+
+Frame captures are available too: `frameUrl(id, 1, 'hq')` gives `hq1.jpg`
+(frames 1-3 are taken at roughly 25/50/75% of the video; `0.jpg` is the default frame).
+
+## API
+
+- `getVideoId(input) -> string | null`
+- `thumbnailUrl(idOrUrl, size = 'maxresdefault', { host, format })`
+- `thumbnailUrls(idOrUrl, { host, format })`
+- `frameUrl(idOrUrl, frame 0-3, quality '' | 'mq' | 'hq' | 'sd' | 'maxres', { host, format })`
+- `checkThumbnail(url, { fetch, signal })` -> `{ url, ok, status, width, height, bytes }`
+- `resolveThumbnail(idOrUrl, { order, format, host, fetch, signal })`
+- `readDimensions(uint8array)` -> `{ width, height } | null` (JPEG SOF and WebP VP8/VP8L/VP8X)
+- `SIZES`, `FALLBACK_ORDER`, `HOSTS`
+
+`host` accepts `i.ytimg.com` (default), `i1`-`i4.ytimg.com` and `img.youtube.com`;
+they all serve the same files. Pass your own `fetch` (for example `undici` or a
+proxy) if the global one does not suit you.
+
+## Browser
+
+`checkThumbnail` and `resolveThumbnail` send a `Range` request with `fetch`. The
+ytimg servers send `Access-Control-Allow-Origin: *`, so this works from a page as
+well as from Node. If you only need a URL and are happy to detect the grey box
+yourself, `new Image()` with a `naturalWidth > 121` check does the same job.
+
+## Tests
+
+```sh
+npm test              # offline unit tests
+LIVE=1 npm test       # also hits i.ytimg.com for three real videos
+```
+
+## Related
+
+- Online tool: [ThumbnailsGrabber - YouTube thumbnail grabber](https://thumbnailsgrabber.com/)
+- [YouTube Thumbnail URL Guide](https://thumbnailsgrabber.com/youtube-thumbnail-url-guide)
+- [YouTube Thumbnail Statistics (dataset)](https://thumbnailsgrabber.com/youtube-thumbnail-statistics)
+- [Get YouTube thumbnails in Python](https://thumbnailsgrabber.com/youtube-thumbnail-python)
+- [Get YouTube thumbnails from the command line](https://thumbnailsgrabber.com/youtube-thumbnail-command-line)
+
+## License
+
+MIT

package/index.cjs

@@ -0,0 +1,255 @@
+'use strict';
+/*!
+ * youtube-thumbnail-url
+ * Build every YouTube thumbnail URL for a video, and resolve the best one that
+ * really exists (maxresdefault -> sddefault -> hqdefault), checking the HTTP
+ * status and the real pixel width instead of trusting the URL.
+ *
+ * Zero dependencies. Works in Node 18+ and in browsers (uses global fetch).
+ * Maintained by ThumbnailsGrabber - https://thumbnailsgrabber.com
+ * Reference: https://thumbnailsgrabber.com/youtube-thumbnail-url-guide
+ * Data:      https://thumbnailsgrabber.com/youtube-thumbnail-statistics
+ * License: MIT
+ */
+
+var ID_RE = /^[0-9A-Za-z_-]{11}$/;
+
+/**
+ * Every named rendition YouTube serves under /vi/<id>/, with the pixel size
+ * it has when it exists. Frame captures (1.jpg, hq2.jpg ...) are covered by
+ * frameUrl(). Availability figures come from a 2026 measurement of 8,664
+ * public videos: https://thumbnailsgrabber.com/youtube-thumbnail-statistics
+ */
+var SIZES = {
+  default:       { width: 120,  height: 90,   note: 'always exists' },
+  mqdefault:     { width: 320,  height: 180,  note: 'always exists' },
+  hqdefault:     { width: 480,  height: 360,  note: 'always exists (letterboxed 4:3)' },
+  sddefault:     { width: 640,  height: 480,  note: 'about 96% of videos (letterboxed 4:3)' },
+  hq720:         { width: 1280, height: 720,  note: 'same file as maxresdefault when it exists' },
+  maxresdefault: { width: 1280, height: 720,  note: 'about 88% of videos; missing = HTTP 404 with a 120x90 grey body' },
+  oar2:          { width: 1080, height: 1920, note: 'vertical Shorts cover, about 30% of videos (some are 720x1280)' }
+};
+
+/** Landscape ladder, largest first. maxres -> sd -> hq covers 100% of videos. */
+var FALLBACK_ORDER = ['maxresdefault', 'sddefault', 'hqdefault'];
+
+var HOSTS = ['i.ytimg.com', 'i1.ytimg.com', 'i2.ytimg.com', 'i3.ytimg.com', 'i4.ytimg.com', 'img.youtube.com'];
+
+/**
+ * Extract the 11-character video ID from a bare ID or any YouTube URL
+ * (watch?v=, youtu.be/, /shorts/, /embed/, /live/, /v/, music., m., nocookie).
+ * Returns null when nothing that looks like an ID is found.
+ */
+function getVideoId(input) {
+  var raw = String(input == null ? '' : input).trim();
+  if (!raw) return null;
+  if (ID_RE.test(raw)) return raw;
+  if (!/^https?:\/\//i.test(raw)) raw = 'https://' + raw;
+  try {
+    var u = new URL(raw);
+    var v = u.searchParams.get('v');
+    if (v && ID_RE.test(v)) return v;
+    var parts = u.pathname.split('/').filter(Boolean);
+    for (var i = 0; i < parts.length; i++) {
+      var p = parts[i];
+      if ((p === 'shorts' || p === 'embed' || p === 'live' || p === 'v' || p === 'vi' || p === 'vi_webp') && parts[i + 1]) {
+        var c = parts[i + 1].substring(0, 11);
+        if (ID_RE.test(c)) return c;
+      }
+    }
+    var last = (parts[parts.length - 1] || '').substring(0, 11);
+    if (ID_RE.test(last)) return last;
+  } catch (e) { /* fall through */ }
+  var m = String(input).match(/(?:v=|\/)([0-9A-Za-z_-]{11})(?:[?&#\/]|$)/);
+  return m ? m[1] : null;
+}
+
+function normalizeOptions(opts) {
+  opts = opts || {};
+  var host = opts.host || 'i.ytimg.com';
+  if (HOSTS.indexOf(host) === -1) throw new Error('Unknown ytimg host: ' + host);
+  var format = opts.format === 'webp' ? 'webp' : 'jpg';
+  return { host: host, format: format };
+}
+
+/**
+ * URL of one named rendition. size defaults to 'maxresdefault'.
+ * opts.format = 'jpg' (default) | 'webp' (served from /vi_webp/, ~half the bytes).
+ * opts.host   = 'i.ytimg.com' (default) | i1-i4.ytimg.com | 'img.youtube.com'.
+ */
+function thumbnailUrl(idOrUrl, size, opts) {
+  var id = getVideoId(idOrUrl);
+  if (!id) throw new Error('Could not find a YouTube video ID in: ' + idOrUrl);
+  size = size || 'maxresdefault';
+  if (!SIZES[size]) throw new Error('Unknown thumbnail size: ' + size + ' (expected one of ' + Object.keys(SIZES).join(', ') + ')');
+  var o = normalizeOptions(opts);
+  var dir = o.format === 'webp' ? 'vi_webp' : 'vi';
+  return 'https://' + o.host + '/' + dir + '/' + id + '/' + size + '.' + o.format;
+}
+
+/**
+ * URL of an auto-captured frame. frame 0 = the default thumbnail frame, 1-3 =
+ * frames at roughly 25/50/75% of the video. quality '' (120x90) | 'mq' | 'hq' | 'sd' | 'maxres'.
+ */
+function frameUrl(idOrUrl, frame, quality, opts) {
+  var id = getVideoId(idOrUrl);
+  if (!id) throw new Error('Could not find a YouTube video ID in: ' + idOrUrl);
+  frame = Number(frame);
+  if (!(frame >= 0 && frame <= 3 && frame === Math.floor(frame))) throw new Error('frame must be 0, 1, 2 or 3');
+  quality = quality || '';
+  if (['', 'mq', 'hq', 'sd', 'maxres'].indexOf(quality) === -1) throw new Error('quality must be "", "mq", "hq", "sd" or "maxres"');
+  var o = normalizeOptions(opts);
+  var dir = o.format === 'webp' ? 'vi_webp' : 'vi';
+  return 'https://' + o.host + '/' + dir + '/' + id + '/' + quality + frame + '.' + o.format;
+}
+
+/**
+ * All named renditions at once: { maxresdefault: { url, width, height }, ... }.
+ * Widths/heights are the sizes the file has WHEN IT EXISTS - use resolveThumbnail()
+ * to find out which ones actually do.
+ */
+function thumbnailUrls(idOrUrl, opts) {
+  var out = {};
+  Object.keys(SIZES).forEach(function (size) {
+    out[size] = {
+      url: thumbnailUrl(idOrUrl, size, opts),
+      width: SIZES[size].width,
+      height: SIZES[size].height
+    };
+  });
+  return out;
+}
+
+/* ---------- image header parsing (first ~4 KB is enough) ---------- */
+
+function readDimensions(bytes) {
+  if (!bytes || bytes.length < 16) return null;
+  // JPEG: scan markers for a SOF segment.
+  if (bytes[0] === 0xFF && bytes[1] === 0xD8) {
+    var i = 2;
+    while (i + 9 < bytes.length) {
+      if (bytes[i] !== 0xFF) { i++; continue; }
+      var marker = bytes[i + 1];
+      if (marker === 0xFF) { i++; continue; }
+      if (marker === 0xD8 || (marker >= 0xD0 && marker <= 0xD7) || marker === 0x01) { i += 2; continue; }
+      var len = (bytes[i + 2] << 8) | bytes[i + 3];
+      var isSOF = (marker >= 0xC0 && marker <= 0xCF) && marker !== 0xC4 && marker !== 0xC8 && marker !== 0xCC;
+      if (isSOF) {
+        return { height: (bytes[i + 5] << 8) | bytes[i + 6], width: (bytes[i + 7] << 8) | bytes[i + 8] };
+      }
+      if (marker === 0xDA) break; // start of scan, no SOF seen
+      i += 2 + len;
+    }
+    return null;
+  }
+  // WebP: RIFF....WEBP + VP8 / VP8L / VP8X chunk.
+  if (bytes[0] === 0x52 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x46 &&
+      bytes[8] === 0x57 && bytes[9] === 0x45 && bytes[10] === 0x42 && bytes[11] === 0x50 && bytes.length >= 25) {
+    var chunk = String.fromCharCode(bytes[12], bytes[13], bytes[14], bytes[15]);
+    if (chunk === 'VP8 ') {
+      return { width: ((bytes[27] << 8) | bytes[26]) & 0x3FFF, height: ((bytes[29] << 8) | bytes[28]) & 0x3FFF };
+    }
+    if (chunk === 'VP8L') {
+      var b0 = bytes[21], b1 = bytes[22], b2 = bytes[23], b3 = bytes[24];
+      return { width: 1 + (((b1 & 0x3F) << 8) | b0), height: 1 + (((b3 & 0x0F) << 10) | (b2 << 2) | ((b1 & 0xC0) >> 6)) };
+    }
+    if (chunk === 'VP8X' && bytes.length >= 30) {
+      return { width: 1 + (bytes[24] | (bytes[25] << 8) | (bytes[26] << 16)), height: 1 + (bytes[27] | (bytes[28] << 8) | (bytes[29] << 16)) };
+    }
+  }
+  return null;
+}
+
+function parseTotalBytes(res) {
+  var cr = res.headers && res.headers.get && res.headers.get('content-range');
+  if (cr) { var m = /\/(\d+)\s*$/.exec(cr); if (m) return Number(m[1]); }
+  var cl = res.headers && res.headers.get && res.headers.get('content-length');
+  return cl ? Number(cl) : null;
+}
+
+/**
+ * Check whether one thumbnail URL is a real image.
+ * Downloads only the first 4 KB (Range request) and parses the JPEG/WebP header.
+ * Resolves { url, ok, status, width, height, bytes }.
+ *   ok = HTTP 2xx AND (width unknown OR width > 121).
+ * A missing maxresdefault/sddefault/oar2 is an HTTP 404 whose body is still a
+ * 120x90 grey JPEG, so <img> tags render a tiny grey box; both checks catch it.
+ */
+function checkThumbnail(url, opts) {
+  opts = opts || {};
+  var f = opts.fetch || (typeof fetch === 'function' ? fetch : null);
+  if (!f) return Promise.reject(new Error('No fetch available; pass opts.fetch'));
+  var init = { method: 'GET', headers: { Range: 'bytes=0-4095' }, redirect: 'follow' };
+  if (opts.signal) init.signal = opts.signal;
+  return f(url, init).then(function (res) {
+    var status = res.status;
+    var bytes = parseTotalBytes(res);
+    if (status < 200 || status > 299) {
+      return res.arrayBuffer().then(function () { return null; }, function () { return null; }).then(function () {
+        return { url: url, ok: false, status: status, width: null, height: null, bytes: bytes };
+      });
+    }
+    return res.arrayBuffer().then(function (buf) {
+      var dims = readDimensions(new Uint8Array(buf));
+      if (status === 200 && bytes == null) bytes = buf.byteLength;
+      var width = dims ? dims.width : null;
+      var height = dims ? dims.height : null;
+      var ok = width == null ? true : width > 121;
+      return { url: url, ok: ok, status: status, width: width, height: height, bytes: bytes };
+    });
+  });
+}
+
+/**
+ * Find the largest thumbnail that really exists.
+ * opts.order   = ['maxresdefault','sddefault','hqdefault'] (default). Add 'oar2'
+ *                first to prefer the vertical Shorts cover when there is one.
+ * opts.format  = 'jpg' | 'webp'  (webp falls back to jpg when webp is missing)
+ * opts.host, opts.fetch, opts.signal as in checkThumbnail.
+ * Resolves { id, size, url, width, height, bytes, status, checked: [...] }.
+ * Never rejects for a missing rendition; rejects only when no size responded 2xx.
+ */
+function resolveThumbnail(idOrUrl, opts) {
+  opts = opts || {};
+  var id = getVideoId(idOrUrl);
+  if (!id) return Promise.reject(new Error('Could not find a YouTube video ID in: ' + idOrUrl));
+  var order = (opts.order && opts.order.length) ? opts.order.slice() : FALLBACK_ORDER.slice();
+  var formats = opts.format === 'webp' ? ['webp', 'jpg'] : ['jpg'];
+  var checked = [];
+  var attempts = [];
+  order.forEach(function (size) {
+    formats.forEach(function (fmt) { attempts.push({ size: size, format: fmt }); });
+  });
+  var i = 0;
+  function next() {
+    if (i >= attempts.length) {
+      var err = new Error('No thumbnail responded 2xx for video ' + id);
+      err.checked = checked;
+      return Promise.reject(err);
+    }
+    var a = attempts[i++];
+    var url = thumbnailUrl(id, a.size, { host: opts.host, format: a.format });
+    return checkThumbnail(url, opts).then(function (r) {
+      r.size = a.size; r.format = a.format;
+      checked.push(r);
+      if (r.ok) {
+        return { id: id, size: a.size, format: a.format, url: r.url, width: r.width, height: r.height, bytes: r.bytes, status: r.status, checked: checked };
+      }
+      return next();
+    });
+  }
+  return next();
+}
+
+module.exports = {
+  SIZES: SIZES,
+  FALLBACK_ORDER: FALLBACK_ORDER,
+  HOSTS: HOSTS,
+  getVideoId: getVideoId,
+  thumbnailUrl: thumbnailUrl,
+  thumbnailUrls: thumbnailUrls,
+  frameUrl: frameUrl,
+  checkThumbnail: checkThumbnail,
+  resolveThumbnail: resolveThumbnail,
+  readDimensions: readDimensions
+};

package/index.d.ts

@@ -0,0 +1,36 @@
+export type ThumbnailSize =
+  | 'default' | 'mqdefault' | 'hqdefault' | 'sddefault' | 'hq720' | 'maxresdefault' | 'oar2';
+export type ThumbnailFormat = 'jpg' | 'webp';
+export type YtimgHost =
+  | 'i.ytimg.com' | 'i1.ytimg.com' | 'i2.ytimg.com' | 'i3.ytimg.com' | 'i4.ytimg.com' | 'img.youtube.com';
+
+export interface UrlOptions { host?: YtimgHost; format?: ThumbnailFormat; }
+export interface FetchOptions extends UrlOptions {
+  fetch?: typeof fetch;
+  signal?: AbortSignal;
+}
+export interface ResolveOptions extends FetchOptions { order?: ThumbnailSize[]; }
+
+export interface SizeInfo { width: number; height: number; note: string; }
+export interface UrlInfo { url: string; width: number; height: number; }
+export interface CheckResult {
+  url: string; ok: boolean; status: number;
+  width: number | null; height: number | null; bytes: number | null;
+  size?: ThumbnailSize; format?: ThumbnailFormat;
+}
+export interface ResolveResult {
+  id: string; size: ThumbnailSize; format: ThumbnailFormat; url: string;
+  width: number | null; height: number | null; bytes: number | null; status: number;
+  checked: CheckResult[];
+}
+
+export const SIZES: Record<ThumbnailSize, SizeInfo>;
+export const FALLBACK_ORDER: ThumbnailSize[];
+export const HOSTS: YtimgHost[];
+export function getVideoId(input: string): string | null;
+export function thumbnailUrl(idOrUrl: string, size?: ThumbnailSize, opts?: UrlOptions): string;
+export function thumbnailUrls(idOrUrl: string, opts?: UrlOptions): Record<ThumbnailSize, UrlInfo>;
+export function frameUrl(idOrUrl: string, frame: 0 | 1 | 2 | 3, quality?: '' | 'mq' | 'hq' | 'sd' | 'maxres', opts?: UrlOptions): string;
+export function checkThumbnail(url: string, opts?: FetchOptions): Promise<CheckResult>;
+export function resolveThumbnail(idOrUrl: string, opts?: ResolveOptions): Promise<ResolveResult>;
+export function readDimensions(bytes: Uint8Array): { width: number; height: number } | null;

package/index.mjs

@@ -0,0 +1,7 @@
+import m from './index.cjs';
+export const {
+  SIZES, FALLBACK_ORDER, HOSTS,
+  getVideoId, thumbnailUrl, thumbnailUrls, frameUrl,
+  checkThumbnail, resolveThumbnail, readDimensions
+} = m;
+export default m;

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "youtube-thumbnail-url",
+  "version": "0.1.0",
+  "description": "Build every YouTube thumbnail URL (maxresdefault, sddefault, hqdefault, WebP, Shorts oar2) and resolve the largest one that really exists, with a fallback that checks HTTP status and real pixel width.",
+  "keywords": ["youtube", "thumbnail", "thumbnails", "ytimg", "maxresdefault", "video", "image", "url", "shorts", "webp"],
+  "homepage": "https://thumbnailsgrabber.com/youtube-thumbnail-url-guide",
+  "license": "MIT",
+  "author": "ThumbnailsGrabber (https://thumbnailsgrabber.com)",
+  "main": "./index.cjs",
+  "module": "./index.mjs",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.mjs",
+      "require": "./index.cjs"
+    }
+  },
+  "files": ["index.cjs", "index.mjs", "index.d.ts", "README.md", "LICENSE"],
+  "sideEffects": false,
+  "engines": { "node": ">=18" },
+  "scripts": {
+    "test": "node --test test/*.test.cjs",
+    "test:live": "LIVE=1 node --test test/*.test.cjs"
+  }
+}