xvideo-dll 0.0.0-stage → 1.0.0

package/README.md

@@ -1,3 +1,89 @@
-# Temporary Holding Version
+# xvideo-download
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Librería para Node.js que obtiene la información y las resoluciones disponibles de un video y lo descarga.
+
+- Lee los datos básicos de la página (título, miniatura, descripción).
+- Detecta todas las calidades: MP4 directo (`mp4-low`, `mp4-high`) y HLS (`hls-480p`, `hls-720p`, ...).
+- Descarga HLS en paralelo y lo convierte a un **MP4 real** (reproducible en navegador, VS Code, etc.).
+- **No necesita ffmpeg.**
+- Si la URL firmada caduca a mitad de la descarga, puede renovarla automáticamente.
+
+## Requisitos
+
+- Node.js 18 o superior.
+
+## Instalación
+
+```bash
+npm install xvideo-download
+```
+
+## Uso rápido
+
+```ts
+import { fetchPageHtml, parseVideo, getResolutions, download } from "xvideo-download";
+
+const pageUrl = "https://sitio.com/video/xxxx";
+
+// 1. Descargar la página (siempre en vivo: las URLs caducan)
+const html = await fetchPageHtml(pageUrl);
+
+// 2. Información básica
+console.log(parseVideo(html));
+// { title, thumbnail, description, jsonLd }
+
+// 3. Resoluciones disponibles
+const resolutions = await getResolutions(html);
+console.log(Object.keys(resolutions));
+// [ "mp4-low", "mp4-high", "hls-250p", "hls-480p", ... ]
+
+// 4. Descargar una
+const key = "hls-480p";
+const result = await download(
+  resolutions[key],
+  "video.mp4",
+  (p) => console.log(`${Math.round(p * 100)}%`), // progreso (0 a 1)
+  8,                                              // conexiones en paralelo (solo HLS)
+  async () => {                                   // opcional: renovar la URL si caduca
+    const fresh = await getResolutions(await fetchPageHtml(pageUrl));
+    return fresh[key];
+  }
+);
+
+console.log(result); // { path: "video.mp4", bytes: 13967360 }
+```
+
+También funciona con `require`:
+
+```js
+const { fetchPageHtml, getResolutions, download } = require("xvideo-download");
+```
+
+## API
+
+| Función | Qué hace |
+|---|---|
+| `fetchPageHtml(url)` | Descarga el HTML de la página (sigue redirecciones). |
+| `getVideoInfo(url)` | Descarga la página y devuelve `parseVideo` de su HTML. |
+| `parseVideo(html)` | Extrae `title`, `thumbnail`, `description` y `jsonLd` de un HTML. |
+| `parsePlayerUrls(html)` | Extrae las URLs `low`, `high` y `hls` del script del reproductor. |
+| `parseHlsMaster(m3u8, masterUrl)` | Convierte una lista maestra `.m3u8` en `{ "hls-720p": url, ... }`. |
+| `getResolutions(html)` | Devuelve todas las calidades disponibles. |
+| `download(url, outPath, onProgress?, threads?, refreshUrl?)` | Descarga una resolución. Elige solo el método según la URL. |
+| `downloadHlsFast(...)` | Descarga HLS en paralelo y lo convierte a MP4. |
+| `downloadFile(url, outPath, onProgress?)` | Descarga un MP4 directo. |
+
+Todas las funciones y los tipos `VideoInfo` y `Resolutions` se exportan.
+
+## Cosas a tener en cuenta
+
+- **Las URLs caducan.** Contienen un token con tiempo limitado. Pide siempre la página con `fetchPageHtml` justo antes de descargar y no guardes las URLs para usarlas después.
+- **Descarga HLS:** se baja en segmentos a una carpeta temporal (`.hls_temp_*`, junto al archivo de salida), se unen y se convierten a MP4. La carpeta se borra al terminar, incluso si hay un error.
+- **Memoria:** en HLS el video completo pasa por la memoria durante la conversión. Es cómodo para videos de decenas de MB; con archivos muy grandes consumirá bastante RAM.
+- **MP4 directo:** se descarga con una sola conexión (el parámetro `threads` no aplica).
+- **Compatibilidad:** está pensada para páginas cuyo reproductor expone `setVideoUrlLow`, `setVideoUrlHigh` y `setVideoHLS`. Si el sitio cambia ese código, hay que ajustar `parsePlayerUrls`.
+- **Uso responsable:** respeta los términos de uso del sitio y los derechos de autor del contenido, y no hagas muchas peticiones seguidas.
+
+## Licencia
+
+ISC

package/dist/index.cjs

@@ -0,0 +1,224 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  download: () => download,
+  downloadFile: () => downloadFile,
+  downloadHlsFast: () => downloadHlsFast,
+  fetchPageHtml: () => fetchPageHtml,
+  getResolutions: () => getResolutions,
+  getVideoInfo: () => getVideoInfo,
+  parseHlsMaster: () => parseHlsMaster,
+  parsePlayerUrls: () => parsePlayerUrls,
+  parseVideo: () => parseVideo
+});
+module.exports = __toCommonJS(index_exports);
+var cheerio = __toESM(require("cheerio"), 1);
+var import_promises = require("fs/promises");
+var import_node_fs = require("fs");
+var import_node_stream = require("stream");
+var import_promises2 = require("stream/promises");
+var import_node_path = __toESM(require("path"), 1);
+var import_mediabunny = require("mediabunny");
+function parseVideo(html) {
+  const $ = cheerio.load(html);
+  const meta = (p) => $(`meta[property="${p}"]`).attr("content") ?? null;
+  let jsonLd = null;
+  try {
+    const raw = $('script[type="application/ld+json"]').first().html();
+    if (raw) jsonLd = JSON.parse(raw);
+  } catch {
+  }
+  return {
+    title: meta("og:title") ?? ($("title").text() || null),
+    thumbnail: meta("og:image"),
+    description: meta("og:description"),
+    jsonLd
+  };
+}
+async function getVideoInfo(url) {
+  const res = await fetch(url, { redirect: "follow", headers: { "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)" } });
+  if (!res.ok) throw new Error(`HTTP ${res.status} en ${url}`);
+  return parseVideo(await res.text());
+}
+async function fetchPageHtml(url) {
+  const res = await fetch(url, { redirect: "follow", headers: { "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)" } });
+  if (!res.ok) throw new Error(`HTTP ${res.status} en ${url}`);
+  return res.text();
+}
+function parsePlayerUrls(html) {
+  const grab = (name) => html.match(new RegExp(`setVideo${name}\\(\\s*['"]([^'"]+)['"]\\s*\\)`))?.[1] ?? null;
+  return { low: grab("UrlLow"), high: grab("UrlHigh"), hls: grab("HLS") };
+}
+function parseHlsMaster(m3u8, masterUrl) {
+  const out = {};
+  const lines = m3u8.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.startsWith("#EXT-X-STREAM-INF")) continue;
+    const height = line.match(/RESOLUTION=\d+x(\d+)/)?.[1];
+    const next = lines[i + 1]?.trim();
+    if (!height || !next) continue;
+    out[`hls-${height}p`] = new URL(next, masterUrl).href;
+  }
+  return out;
+}
+async function getResolutions(html) {
+  const { low, high, hls } = parsePlayerUrls(html);
+  const resolutions = {};
+  if (low) resolutions["mp4-low"] = low;
+  if (high) resolutions["mp4-high"] = high;
+  if (hls) {
+    const res = await fetch(hls, { headers: { "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)" } });
+    if (res.ok) {
+      Object.assign(resolutions, parseHlsMaster(await res.text(), hls));
+    } else {
+      console.warn(`\u26A0 No se pudo leer el playlist HLS: HTTP ${res.status} en ${hls}`);
+    }
+  } else {
+    console.warn("\u26A0 No se encontr\xF3 setVideoHLS(...) en el HTML");
+  }
+  return resolutions;
+}
+async function remuxTsToMp4(tsData, outPath) {
+  const input = new import_mediabunny.Input({
+    source: new import_mediabunny.BufferSource(tsData),
+    formats: import_mediabunny.ALL_FORMATS
+  });
+  const target = new import_mediabunny.BufferTarget();
+  const output = new import_mediabunny.Output({
+    format: new import_mediabunny.Mp4OutputFormat({ fastStart: "in-memory" }),
+    target
+  });
+  const conversion = await import_mediabunny.Conversion.init({ input, output });
+  if (!conversion.isValid) {
+    throw new Error(
+      "Conversi\xF3n inv\xE1lida. Pistas descartadas: " + JSON.stringify(conversion.discardedTracks)
+    );
+  }
+  await conversion.execute();
+  if (!target.buffer) throw new Error("mediabunny no gener\xF3 ning\xFAn buffer");
+  await (0, import_promises.writeFile)(outPath, new Uint8Array(target.buffer));
+}
+async function fetchSegmentList(m3u8Url) {
+  const res = await fetch(m3u8Url, { headers: { "user-agent": "Mozilla/5.0" } });
+  if (!res.ok) throw new Error(`HTTP ${res.status} en ${m3u8Url}`);
+  const segments = [];
+  for (const raw of (await res.text()).split(/\r?\n/)) {
+    const line = raw.trim();
+    if (line && !line.startsWith("#") && !line.endsWith(".m3u8")) {
+      segments.push(new URL(line, m3u8Url).href);
+    }
+  }
+  if (segments.length === 0) throw new Error("No se encontraron segmentos HLS v\xE1lidos");
+  return segments;
+}
+async function downloadHlsFast(m3u8Url, outPath, concurrency = 8, onProgress, refreshUrl) {
+  let segments = await fetchSegmentList(m3u8Url);
+  const total = segments.length;
+  const tempDir = import_node_path.default.join(import_node_path.default.dirname(outPath), `.hls_temp_${Date.now()}`);
+  await (0, import_promises.mkdir)(tempDir, { recursive: true });
+  try {
+    let completed = 0;
+    const tasks = Array.from({ length: total }, (_, index) => async () => {
+      let buffer = null;
+      let lastStatus = 0;
+      for (let attempt = 0; attempt < 5 && !buffer; attempt++) {
+        try {
+          const segRes = await fetch(segments[index], { headers: { "user-agent": "Mozilla/5.0" } });
+          if (segRes.ok) {
+            buffer = Buffer.from(await segRes.arrayBuffer());
+            break;
+          }
+          lastStatus = segRes.status;
+          if (segRes.status === 410 || segRes.status === 403) {
+            if (refreshUrl) m3u8Url = await refreshUrl();
+            const fresh = await fetchSegmentList(m3u8Url);
+            if (fresh.length === total) segments = fresh;
+          }
+        } catch {
+          lastStatus = -1;
+        }
+        await new Promise((r) => setTimeout(r, 500 * (attempt + 1)));
+      }
+      if (!buffer) throw new Error(`Fallo segmento ${index}: ${lastStatus}`);
+      const filePath = import_node_path.default.join(tempDir, `${index.toString().padStart(5, "0")}.ts`);
+      await (0, import_promises.writeFile)(filePath, buffer);
+      completed++;
+      if (onProgress) onProgress(completed / total);
+    });
+    for (let i = 0; i < tasks.length; i += concurrency) {
+      const batch = tasks.slice(i, i + concurrency);
+      await Promise.all(batch.map((t) => t()));
+    }
+    const parts = [];
+    for (let i = 0; i < total; i++) {
+      const filePath = import_node_path.default.join(tempDir, `${i.toString().padStart(5, "0")}.ts`);
+      parts.push(await import_node_fs.promises.readFile(filePath));
+    }
+    const merged = Buffer.concat(parts);
+    await remuxTsToMp4(merged, outPath);
+  } finally {
+    await (0, import_promises.rm)(tempDir, { recursive: true, force: true });
+  }
+  const stats = await import_node_fs.promises.stat(outPath);
+  return { path: outPath, bytes: stats.size };
+}
+async function downloadFile(url, outPath, onProgress) {
+  const res = await fetch(url, { headers: { "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)" } });
+  if (!res.ok || !res.body) throw new Error(`HTTP ${res.status} en ${url}`);
+  const total = Number(res.headers.get("content-length")) || 0;
+  let received = 0;
+  const body = import_node_stream.Readable.fromWeb(res.body);
+  body.on("data", (chunk) => {
+    received += chunk.length;
+    if (total && onProgress) onProgress(received / total);
+  });
+  await (0, import_promises2.pipeline)(body, (0, import_node_fs.createWriteStream)(outPath));
+  return { path: outPath, bytes: received };
+}
+function download(url, outPath, onProgress, threads = 8, refreshUrl) {
+  if (url.includes(".m3u8")) {
+    return downloadHlsFast(url, outPath, threads, onProgress, refreshUrl);
+  }
+  return downloadFile(url, outPath, onProgress);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  download,
+  downloadFile,
+  downloadHlsFast,
+  fetchPageHtml,
+  getResolutions,
+  getVideoInfo,
+  parseHlsMaster,
+  parsePlayerUrls,
+  parseVideo
+});

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+export interface VideoInfo {
+    title: string | null;
+    thumbnail: string | null;
+    description: string | null;
+    jsonLd: unknown | null;
+}
+export declare function parseVideo(html: string): VideoInfo;
+export declare function getVideoInfo(url: string): Promise<VideoInfo>;
+/** Descarga el HTML de la página del video EN VIVO (genera URLs firmadas nuevas). */
+export declare function fetchPageHtml(url: string): Promise<string>;
+export type Resolutions = Record<string, string>;
+export declare function parsePlayerUrls(html: string): {
+    low: string | null;
+    high: string | null;
+    hls: string | null;
+};
+export declare function parseHlsMaster(m3u8: string, masterUrl: string): Resolutions;
+export declare function getResolutions(html: string): Promise<Resolutions>;
+/**
+ * Descarga HLS: segmentos .ts en paralelo, unión en memoria y remux a MP4 real.
+ */
+export declare function downloadHlsFast(m3u8Url: string, outPath: string, concurrency?: number, onProgress?: (p: number) => void, refreshUrl?: () => Promise<string>): Promise<{
+    path: string;
+    bytes: number;
+}>;
+export declare function downloadFile(url: string, outPath: string, onProgress?: (p: number) => void): Promise<{
+    path: string;
+    bytes: number;
+}>;
+export declare function download(url: string, outPath: string, onProgress?: (p: number) => void, threads?: number, refreshUrl?: () => Promise<string>): Promise<{
+    path: string;
+    bytes: number;
+}>;

package/dist/index.js

@@ -0,0 +1,190 @@
+// src/index.ts
+import * as cheerio from "cheerio";
+import { writeFile, mkdir, rm } from "fs/promises";
+import { createWriteStream, promises as fsPromises } from "fs";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+import path from "path";
+import {
+  Input,
+  Output,
+  Conversion,
+  BufferSource,
+  BufferTarget,
+  ALL_FORMATS,
+  Mp4OutputFormat
+} from "mediabunny";
+function parseVideo(html) {
+  const $ = cheerio.load(html);
+  const meta = (p) => $(`meta[property="${p}"]`).attr("content") ?? null;
+  let jsonLd = null;
+  try {
+    const raw = $('script[type="application/ld+json"]').first().html();
+    if (raw) jsonLd = JSON.parse(raw);
+  } catch {
+  }
+  return {
+    title: meta("og:title") ?? ($("title").text() || null),
+    thumbnail: meta("og:image"),
+    description: meta("og:description"),
+    jsonLd
+  };
+}
+async function getVideoInfo(url) {
+  const res = await fetch(url, { redirect: "follow", headers: { "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)" } });
+  if (!res.ok) throw new Error(`HTTP ${res.status} en ${url}`);
+  return parseVideo(await res.text());
+}
+async function fetchPageHtml(url) {
+  const res = await fetch(url, { redirect: "follow", headers: { "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)" } });
+  if (!res.ok) throw new Error(`HTTP ${res.status} en ${url}`);
+  return res.text();
+}
+function parsePlayerUrls(html) {
+  const grab = (name) => html.match(new RegExp(`setVideo${name}\\(\\s*['"]([^'"]+)['"]\\s*\\)`))?.[1] ?? null;
+  return { low: grab("UrlLow"), high: grab("UrlHigh"), hls: grab("HLS") };
+}
+function parseHlsMaster(m3u8, masterUrl) {
+  const out = {};
+  const lines = m3u8.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (!line.startsWith("#EXT-X-STREAM-INF")) continue;
+    const height = line.match(/RESOLUTION=\d+x(\d+)/)?.[1];
+    const next = lines[i + 1]?.trim();
+    if (!height || !next) continue;
+    out[`hls-${height}p`] = new URL(next, masterUrl).href;
+  }
+  return out;
+}
+async function getResolutions(html) {
+  const { low, high, hls } = parsePlayerUrls(html);
+  const resolutions = {};
+  if (low) resolutions["mp4-low"] = low;
+  if (high) resolutions["mp4-high"] = high;
+  if (hls) {
+    const res = await fetch(hls, { headers: { "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)" } });
+    if (res.ok) {
+      Object.assign(resolutions, parseHlsMaster(await res.text(), hls));
+    } else {
+      console.warn(`\u26A0 No se pudo leer el playlist HLS: HTTP ${res.status} en ${hls}`);
+    }
+  } else {
+    console.warn("\u26A0 No se encontr\xF3 setVideoHLS(...) en el HTML");
+  }
+  return resolutions;
+}
+async function remuxTsToMp4(tsData, outPath) {
+  const input = new Input({
+    source: new BufferSource(tsData),
+    formats: ALL_FORMATS
+  });
+  const target = new BufferTarget();
+  const output = new Output({
+    format: new Mp4OutputFormat({ fastStart: "in-memory" }),
+    target
+  });
+  const conversion = await Conversion.init({ input, output });
+  if (!conversion.isValid) {
+    throw new Error(
+      "Conversi\xF3n inv\xE1lida. Pistas descartadas: " + JSON.stringify(conversion.discardedTracks)
+    );
+  }
+  await conversion.execute();
+  if (!target.buffer) throw new Error("mediabunny no gener\xF3 ning\xFAn buffer");
+  await writeFile(outPath, new Uint8Array(target.buffer));
+}
+async function fetchSegmentList(m3u8Url) {
+  const res = await fetch(m3u8Url, { headers: { "user-agent": "Mozilla/5.0" } });
+  if (!res.ok) throw new Error(`HTTP ${res.status} en ${m3u8Url}`);
+  const segments = [];
+  for (const raw of (await res.text()).split(/\r?\n/)) {
+    const line = raw.trim();
+    if (line && !line.startsWith("#") && !line.endsWith(".m3u8")) {
+      segments.push(new URL(line, m3u8Url).href);
+    }
+  }
+  if (segments.length === 0) throw new Error("No se encontraron segmentos HLS v\xE1lidos");
+  return segments;
+}
+async function downloadHlsFast(m3u8Url, outPath, concurrency = 8, onProgress, refreshUrl) {
+  let segments = await fetchSegmentList(m3u8Url);
+  const total = segments.length;
+  const tempDir = path.join(path.dirname(outPath), `.hls_temp_${Date.now()}`);
+  await mkdir(tempDir, { recursive: true });
+  try {
+    let completed = 0;
+    const tasks = Array.from({ length: total }, (_, index) => async () => {
+      let buffer = null;
+      let lastStatus = 0;
+      for (let attempt = 0; attempt < 5 && !buffer; attempt++) {
+        try {
+          const segRes = await fetch(segments[index], { headers: { "user-agent": "Mozilla/5.0" } });
+          if (segRes.ok) {
+            buffer = Buffer.from(await segRes.arrayBuffer());
+            break;
+          }
+          lastStatus = segRes.status;
+          if (segRes.status === 410 || segRes.status === 403) {
+            if (refreshUrl) m3u8Url = await refreshUrl();
+            const fresh = await fetchSegmentList(m3u8Url);
+            if (fresh.length === total) segments = fresh;
+          }
+        } catch {
+          lastStatus = -1;
+        }
+        await new Promise((r) => setTimeout(r, 500 * (attempt + 1)));
+      }
+      if (!buffer) throw new Error(`Fallo segmento ${index}: ${lastStatus}`);
+      const filePath = path.join(tempDir, `${index.toString().padStart(5, "0")}.ts`);
+      await writeFile(filePath, buffer);
+      completed++;
+      if (onProgress) onProgress(completed / total);
+    });
+    for (let i = 0; i < tasks.length; i += concurrency) {
+      const batch = tasks.slice(i, i + concurrency);
+      await Promise.all(batch.map((t) => t()));
+    }
+    const parts = [];
+    for (let i = 0; i < total; i++) {
+      const filePath = path.join(tempDir, `${i.toString().padStart(5, "0")}.ts`);
+      parts.push(await fsPromises.readFile(filePath));
+    }
+    const merged = Buffer.concat(parts);
+    await remuxTsToMp4(merged, outPath);
+  } finally {
+    await rm(tempDir, { recursive: true, force: true });
+  }
+  const stats = await fsPromises.stat(outPath);
+  return { path: outPath, bytes: stats.size };
+}
+async function downloadFile(url, outPath, onProgress) {
+  const res = await fetch(url, { headers: { "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)" } });
+  if (!res.ok || !res.body) throw new Error(`HTTP ${res.status} en ${url}`);
+  const total = Number(res.headers.get("content-length")) || 0;
+  let received = 0;
+  const body = Readable.fromWeb(res.body);
+  body.on("data", (chunk) => {
+    received += chunk.length;
+    if (total && onProgress) onProgress(received / total);
+  });
+  await pipeline(body, createWriteStream(outPath));
+  return { path: outPath, bytes: received };
+}
+function download(url, outPath, onProgress, threads = 8, refreshUrl) {
+  if (url.includes(".m3u8")) {
+    return downloadHlsFast(url, outPath, threads, onProgress, refreshUrl);
+  }
+  return downloadFile(url, outPath, onProgress);
+}
+export {
+  download,
+  downloadFile,
+  downloadHlsFast,
+  fetchPageHtml,
+  getResolutions,
+  getVideoInfo,
+  parseHlsMaster,
+  parsePlayerUrls,
+  parseVideo
+};

package/package.json

@@ -1,6 +1,54 @@
 {
   "name": "xvideo-dll",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0",
+  "description": "Obtiene la info y las resoluciones de un video y lo descarga (MP4 directo o HLS convertido a MP4 real) sin necesitar ffmpeg.",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --clean --target node18 && tsc src/index.ts --declaration --emitDeclarationOnly --outDir dist --skipLibCheck --module esnext --moduleResolution bundler --target es2022 --strict",
+    "prepublishOnly": "pnpm build"
+  },
+  "keywords": [
+    "video",
+    "download",
+    "downloader",
+    "hls",
+    "m3u8",
+    "mp4",
+    "scraper"
+  ],
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@12.16.1",
+  "type": "module",
+  "devDependencies": {
+    "@clack/prompts": "^1.8.1",
+    "@types/node": "^26.6.6",
+    "tsup": "^9.0.0",
+    "typescript": "^7.0.2",
+    "vitest": "^5.1.0"
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "dependencies": {
+    "cheerio": "^1.2.0",
+    "mediabunny": "1.61.4"
+  }
 }