@lzwme/m3u8-dl 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 renxia<lzwy0820@qq.com, https://lzw.me>
+
+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,140 @@
+[![@lzwme/m3u8-dl](https://nodei.co/npm/@lzwme/m3u8-dl.png)][npm-url]
+
+# @lzwme/m3u8-dl
+
+[![NPM version][npm-badge]][npm-url]
+[![node version][node-badge]][node-url]
+![license MIT](https://img.shields.io/github/license/lzwme/m3u8-dl)
+
+[![build status](https://github.com/lzwme/m3u8-dl/actions/workflows/node-ci.yml/badge.svg)](https://github.com/lzwme/m3u8-dl/actions/workflows/node-ci.yml)
+[![npm download][download-badge]][download-url]
+[![GitHub issues][issues-badge]][issues-url]
+[![GitHub forks][forks-badge]][forks-url]
+[![GitHub stars][stars-badge]][stars-url]
+
+一个 m3u8 文件批量下载工具。
+
+## 功能特性(Features)
+
+- 多线程下载。线程池模式的多线程下载。
+- `边下边播模式`。支持使用已下载的 ts 缓存文件在线播放。
+- 支持指定多个 m3u8 地址批量下载。
+- 支持缓存续传。下载失败则保留缓存，重试时只下载失败的片段。
+- 支持常见的 AES 解密。
+- 支持转换为 mp4。**需全局安装 ffmpeg**
+
+## 安装(Install)
+
+```bash
+npm i -g @lzwme/m3u8-dl
+m3u8dl -h
+```
+
+或者使用 `npx`：
+
+```bash
+npx @lzwme/m3u8-dl -h
+```
+
+## 使用(Useage)
+
+提示：如需要下载并转换为 `mp4` 视频格式，您需全局安装 [ffmpeg](https://ffmpeg.org/download.html)。
+
+### 命令行方式(Command Line Interface)
+
+```bash
+m3u8dl --help
+```
+
+**下载指定 URL 的 m3u8 文件：**
+
+```bash
+m3u8dl https://lzw.me/x/m3u8-player/test.m3u8
+```
+
+**批量下载示例一：**
+
+```bash
+# 下载多个文件：
+m3u8dl "第1集｜https://s.xlzys.com/play/zbqMZYRb/index.m3u8" "第2集｜https://s.xlzys.com/play/PdyJXrwe/index.m3u8" --filename "三体"
+```
+
+**批量下载示例二：**
+
+新建文件 `三体.txt`，内容格式：
+
+```txt
+第1集$https://s.xlzys.com/play/zbqMZYRb/index.m3u8
+第2集$https://s.xlzys.com/play/PdyJXrwe/index.m3u8
+第3集$https://s.xlzys.com/play/oeE6x9Ka/index.m3u8
+```
+
+然后执行如下命令：
+
+```bash
+m3u8dl 三体.txt
+```
+
+提示：可创建并指定多个 txt 文件实现对多个影视剧集的一键批量下载。
+
+### API 调用
+
+```ts
+import { m3u8Download } from '@lzwme/m3u8-dl';
+
+// 示例：单文件下载
+m3u8Download('test/t.m3u8', { debug: true, filenmae: '测试视频' });
+
+// 示例：批量下载
+const fileList = ['第一集$$test/t.m3u8'];
+for (const filepath of fileList) {
+  const r = await m3u8Download(filepath, { debug: true, filenmae: '测试视频' });
+  console.log('文件已下载：', r.filepath);
+}
+```
+
+## API 文档
+
+- [https://lzwme.github.io/m3u8-dl/](https://lzwme.github.io/m3u8-dl/)
+
+## 开发(Development)
+
+本地二次开发：
+
+```bash
+git clone git@github.com:lzwme/m3u8-dl.git
+pnpm install
+pnpm dev
+# npm link
+```
+
+或者 [fork](https://github.com/lzwme/m3u8-dl/fork) 本项目进行代码贡献。
+
+**欢迎贡献想法与代码。**
+
+## References
+
+- [ffmpeg download](https://ffmpeg.org/download.html)
+- [m3u8-multi-thread-downloader](https://github.com/sahadev/m3u8Downloader)
+- [m3u8Utils](https://github.com/liupishui/m3u8Utils)
+
+## License
+
+`@lzwme/m3u8-dl` is released under the MIT license.
+
+该插件由[志文工作室](https://lzw.me)开发和维护。
+
+[stars-badge]: https://img.shields.io/github/stars/lzwme/m3u8-dl.svg
+[stars-url]: https://github.com/lzwme/m3u8-dl/stargazers
+[forks-badge]: https://img.shields.io/github/forks/lzwme/m3u8-dl.svg
+[forks-url]: https://github.com/lzwme/m3u8-dl/network
+[issues-badge]: https://img.shields.io/github/issues/lzwme/m3u8-dl.svg
+[issues-url]: https://github.com/lzwme/m3u8-dl/issues
+[npm-badge]: https://img.shields.io/npm/v/@lzwme/m3u8-dl.svg?style=flat-square
+[npm-url]: https://npmjs.com/package/@lzwme/m3u8-dl
+[node-badge]: https://img.shields.io/badge/node.js-%3E=_14.18.0-green.svg?style=flat-square
+[node-url]: https://nodejs.org/download/
+[download-badge]: https://img.shields.io/npm/dm/@lzwme/m3u8-dl.svg?style=flat-square
+[download-url]: https://npmjs.com/package/@lzwme/m3u8-dl
+[bundlephobia-url]: https://bundlephobia.com/result?p=@lzwme/m3u8-dl@latest
+[bundlephobia-badge]: https://badgen.net/bundlephobia/minzip/@lzwme/m3u8-dl@latest

package/bin/m3u8dl.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require('../cjs/cli.js');

package/cjs/cli.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = require("node:path");
+const commander_1 = require("commander");
+const console_log_colors_1 = require("console-log-colors");
+const fe_utils_1 = require("@lzwme/fe-utils");
+const utils_js_1 = require("./lib/utils.js");
+const m3u8_batch_download_1 = require("./m3u8-batch-download");
+const pkg = (0, fe_utils_1.readJsonFileSync)((0, node_path_1.resolve)(__dirname, '../package.json'));
+commander_1.program
+    .version(pkg.version, '-v, --version')
+    .description((0, console_log_colors_1.cyanBright)(pkg.description))
+    .argument('<m3u8Urls...>', 'm3u8 url。也可以是本地 txt 文件，指定一组 m3u8，适用于批量下载的场景')
+    .option('--silent', `开启静默模式。`)
+    .option('--debug', `开启调试模式。`)
+    .option('-F,--filename <name>', `指定下载文件的保存名称。默认取 url md5 值。若指定了多个 url 地址，则会在末尾增加序号`)
+    .option('-n,--thread-num <number>', `并发下载线程数。取决于服务器限制，过多可能会容易下载失败。一般建议不超过 4 个`, '4')
+    .option('-f,--force', `文件已存在时，是否仍继续下载和生成`)
+    .option('--no-progress', `是否不打印进度信息`)
+    .option('--play', `是否边下边看`)
+    .option('--cache-dir <dirpath>', `临时文件保存目录。默认为 cache`)
+    .option('--save-dir <dirpath>', `下载文件保存的路径。默认为当前目录`)
+    .option('--no-del-cache', `下载成功后是否删除临时文件。默认为 true。保存临时文件可以在重复下载时识别缓存`, true)
+    .action(async (urls, options) => {
+    if (options.debug)
+        utils_js_1.logger.updateOptions({ levelType: 'debug' });
+    else if (options.silent)
+        utils_js_1.logger.updateOptions({ levelType: 'silent' });
+    utils_js_1.logger.debug(urls, options);
+    if (options.progress != null)
+        options.showProgress = options.progress;
+    if (urls.length > 0) {
+        await (0, m3u8_batch_download_1.m3u8BatchDownload)(urls, options);
+    }
+    else
+        commander_1.program.help();
+});
+commander_1.program.parse(process.argv);

package/cjs/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lib/m3u8-download';
+export * from './lib/parseM3u8';

package/cjs/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib/m3u8-download"), exports);
+__exportStar(require("./lib/parseM3u8"), exports);

package/cjs/lib/local-play.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { M3u8DLOptions, TsItemInfo } from '../type';
+/**
+ * 边下边看
+ */
+export declare function localPlay(m3u8Info: TsItemInfo[], _options: M3u8DLOptions): Promise<{
+    port: number;
+    origin: string;
+    server: import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+}>;
+export declare function toLocalM3u8(m3u8Info: TsItemInfo[], filepath: string, host?: string): Promise<void>;

package/cjs/lib/local-play.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toLocalM3u8 = exports.localPlay = void 0;
+const fe_utils_1 = require("@lzwme/fe-utils");
+const console_log_colors_1 = require("console-log-colors");
+const node_fs_1 = require("node:fs");
+const node_http_1 = require("node:http");
+const node_path_1 = require("node:path");
+const utils_1 = require("./utils");
+/**
+ * 边下边看
+ */
+async function localPlay(m3u8Info, _options) {
+    if (!m3u8Info?.length)
+        return null;
+    const cacheDir = (0, node_path_1.dirname)(m3u8Info[0].tsOut);
+    const info = await createLocalServer(cacheDir);
+    const filename = (0, fe_utils_1.md5)(cacheDir).slice(0, 8) + `.m3u8`;
+    await toLocalM3u8(m3u8Info, (0, node_path_1.resolve)(cacheDir, filename), info.origin);
+    const playUrl = `https://lzw.me/x/m3u8-player?url=${encodeURIComponent(`${info.origin}/${filename}`)}`;
+    const cmd = `${process.platform === 'win32' ? 'start' : 'open'} ${playUrl}`;
+    (0, fe_utils_1.execSync)(cmd);
+    return info;
+}
+exports.localPlay = localPlay;
+async function toLocalM3u8(m3u8Info, filepath, host = '') {
+    const m3u8ContentList = [
+        `#EXTM3U`,
+        `#EXT-X-VERSION:3`,
+        `#EXT-X-ALLOW-CACHE:YES`,
+        `#EXT-X-TARGETDURATION:${Math.max(...m3u8Info.map(d => d.duration))}`,
+        `#EXT-X-MEDIA-SEQUENCE:0`,
+        // `#EXT-X-KEY:METHOD=AES-128,URI="/api/aes/enc.key"`,
+    ];
+    m3u8Info.forEach(d => {
+        if (d.tsOut)
+            m3u8ContentList.push(`#EXTINF:${Number(d.duration).toFixed(6)},`, `${host}/${(0, node_path_1.basename)(d.tsOut)}`);
+    });
+    m3u8ContentList.push(`#EXT-X-ENDLIST`);
+    const m3u8Content = m3u8ContentList.join('\n');
+    await node_fs_1.promises.writeFile(filepath, m3u8Content, 'utf8');
+}
+exports.toLocalM3u8 = toLocalM3u8;
+async function createLocalServer(baseDir) {
+    const port = await (0, fe_utils_1.findFreePort)();
+    const origin = `http://localhost:${port}`;
+    const server = (0, node_http_1.createServer)((req, res) => {
+        const filename = (0, node_path_1.join)(baseDir, req.url);
+        utils_1.logger.debug('[req]', req.url, filename);
+        if ((0, node_fs_1.existsSync)(filename)) {
+            const stats = (0, node_fs_1.statSync)(filename);
+            const ext = (0, node_path_1.extname)(filename);
+            if (stats.isFile()) {
+                if (ext === '.m3u8')
+                    res.setHeader('Cache-Control', 'no-cache');
+                res.writeHead(200, {
+                    'Last-Modified': stats.mtime.toUTCString(),
+                    'Access-Control-Allow-Headers': '*',
+                    'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
+                    'Access-Control-Allow-Origin': '*',
+                    'Content-Length': String(stats.size),
+                    'Content-Type': ext === '.ts' ? 'video/mp2t' : ext === '.m3u8' ? 'application/vnd.apple.mpegurl' : 'text/plain',
+                });
+                (0, node_fs_1.createReadStream)(filename).pipe(res);
+                return;
+            }
+        }
+        res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+        res.end('Not found');
+    }).listen(port, () => {
+        utils_1.logger.info('Created Local Server:', console_log_colors_1.color.greenBright(origin));
+    });
+    return { port, origin, server };
+}

package/cjs/lib/m3u8-convert.d.ts

@@ -0,0 +1,2 @@
+import type { M3u8DLOptions, TsItemInfo } from '../type';
+export declare function m3u8Convert(options: M3u8DLOptions, data: TsItemInfo[]): Promise<string>;

package/cjs/lib/m3u8-convert.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.m3u8Convert = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const fe_utils_1 = require("@lzwme/fe-utils");
+const console_log_colors_1 = require("console-log-colors");
+const utils_1 = require("./utils");
+async function m3u8Convert(options, data) {
+    let ffmpegSupport = (0, utils_1.isSupportFfmpeg)();
+    let filepath = (0, node_path_1.resolve)(options.saveDir, options.filename);
+    if (!options.force && (0, node_fs_1.existsSync)(filepath))
+        return filepath;
+    if (ffmpegSupport) {
+        const inputFilePath = (0, node_path_1.resolve)(options.cacheDir, 'input.txt');
+        const filesAllArr = data.map(d => (0, node_path_1.resolve)(d.tsOut)).filter(d => (0, node_fs_1.existsSync)(d));
+        await node_fs_1.promises.writeFile(inputFilePath, 'ffconcat version 1.0\nfile ' + filesAllArr.join('\nfile '));
+        const cmd = `ffmpeg -y -f concat -safe 0 -i ${inputFilePath} -acodec copy -vcodec copy -absf aac_adtstoasc ${filepath}`;
+        utils_1.logger.debug('[m3u8-to-mp4]cmd:', (0, console_log_colors_1.cyan)(cmd));
+        const r = (0, fe_utils_1.execSync)(cmd);
+        ffmpegSupport = !r.error;
+        if (r.error)
+            utils_1.logger.error('Conversion to mp4 failed. Please confirm that ffmpeg is installed!', r.stderr);
+    }
+    if (!ffmpegSupport) {
+        filepath = filepath.replace('.mp4', '.ts');
+        if (!options.force && (0, node_fs_1.existsSync)(filepath))
+            return filepath;
+        const buf = Buffer.concat(data.map(d => (0, node_fs_1.readFileSync)(d.tsOut)));
+        await node_fs_1.promises.writeFile(filepath, buf);
+    }
+    utils_1.logger.info(ffmpegSupport ? 'Generated mp4 file:' : 'Merged into ts file:', (0, console_log_colors_1.greenBright)(filepath));
+    return filepath;
+}
+exports.m3u8Convert = m3u8Convert;

package/cjs/lib/m3u8-download.d.ts

@@ -0,0 +1,12 @@
+import type { M3u8DLOptions, TsItemInfo } from '../type';
+export declare function m3u8Download(url: string, options?: M3u8DLOptions): Promise<{
+    options: M3u8DLOptions;
+    m3u8Info: {
+        manifest: any;
+        tsCount: number;
+        durationSecond: number;
+        data: TsItemInfo[];
+        crypto: import("../type").M3u8Crypto;
+    };
+    filepath: string;
+}>;

package/cjs/lib/m3u8-download.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.m3u8Download = void 0;
+const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const fe_utils_1 = require("@lzwme/fe-utils");
+const console_log_colors_1 = require("console-log-colors");
+const utils_1 = require("./utils");
+const worker_pool_1 = require("./worker_pool");
+const parseM3u8_1 = require("./parseM3u8");
+const m3u8_convert_1 = require("./m3u8-convert");
+const local_play_1 = require("./local-play");
+const tsDlFile = (0, node_path_1.resolve)(__dirname, './ts-download.js');
+async function formatOptions(url, opts) {
+    const options = {
+        delCache: !opts.debug,
+        saveDir: process.cwd(),
+        ...opts,
+    };
+    if (!url.startsWith('http')) {
+        url = url.replace('$', '|').replace(/\|\|+/, '|');
+        if (url.includes('|')) {
+            const r = url.split('|');
+            url = r[1];
+            if (!options.filename)
+                options.filename = r[0];
+            else
+                options.filename = `${options.filename.replace(/\.(ts|mp4)$/, '')}-${r[0]}`;
+        }
+    }
+    const urlMd5 = (0, fe_utils_1.md5)(url, false);
+    if (+options.threadNum <= 0)
+        options.threadNum = (0, node_os_1.cpus)().length;
+    if (!options.filename)
+        options.filename = urlMd5;
+    if (!options.filename.endsWith('.mp4'))
+        options.filename += '.mp4';
+    if (!options.cacheDir)
+        options.cacheDir = `cache/${urlMd5}`;
+    if (!(0, node_fs_1.existsSync)(options.cacheDir))
+        await node_fs_1.promises.mkdir(options.cacheDir, { recursive: true });
+    if (options.headers)
+        utils_1.request.setHeaders(options.headers);
+    if (options.debug) {
+        utils_1.logger.updateOptions({ levelType: 'debug' });
+        utils_1.logger.debug('[m3u8-DL]options', options);
+    }
+    return [url, options];
+}
+async function m3u8Download(url, options = {}) {
+    utils_1.logger.info('starting download for', (0, console_log_colors_1.cyanBright)(url));
+    [url, options] = await formatOptions(url, options);
+    const ext = (0, utils_1.isSupportFfmpeg)() ? '.mp4' : '.ts';
+    let filepath = (0, node_path_1.resolve)(options.saveDir, options.filename);
+    if (!filepath.endsWith(ext))
+        filepath += ext;
+    const m3u8Info = await (0, parseM3u8_1.parseM3U8)('', url, options.cacheDir);
+    const result = { options, m3u8Info, filepath };
+    if (!options.force && (0, node_fs_1.existsSync)(filepath)) {
+        utils_1.logger.info('file already exist:', filepath);
+        return result;
+    }
+    if (m3u8Info.tsCount > 0) {
+        const pool = new worker_pool_1.WorkerPool(tsDlFile, options.threadNum);
+        const barrier = new fe_utils_1.Barrier();
+        const playStart = Math.min(options.threadNum + 2, m3u8Info.tsCount);
+        const stats = {
+            /** 下载成功的 ts 数量 */
+            tsSuccess: 0,
+            /** 下载失败的 ts 数量 */
+            tsFailed: 0,
+            /** 下载完成的时长 */
+            duration: 0,
+        };
+        for (const info of m3u8Info.data) {
+            pool.runTask({ info, options: JSON.parse(JSON.stringify(options)), crypto: m3u8Info.crypto }, (err, res) => {
+                if (err) {
+                    console.log('\n');
+                    utils_1.logger.error('[TS-DL][error]', info.index, err, res);
+                }
+                if (!res)
+                    return;
+                if (res.success) {
+                    stats.tsSuccess++;
+                    stats.duration = +(stats.duration + info.duration).toFixed(2);
+                }
+                else {
+                    stats.tsFailed++;
+                }
+                info.success = res.success;
+                const finished = stats.tsFailed + stats.tsSuccess;
+                if (options.showProgress !== false) {
+                    const percent = Math.ceil((finished / m3u8Info.tsCount) * 100);
+                    const processBar = '='.repeat(Math.ceil(percent * 0.4)).padEnd(40, '-');
+                    utils_1.logger.logInline(`Downloading: ${percent}% [${(0, console_log_colors_1.green)(processBar)}] segment: ${finished}/${m3u8Info.tsCount}, duration: ${stats.duration}/${m3u8Info.durationSecond}sec${finished === m3u8Info.tsCount ? '\n' : ''}`);
+                }
+                if (options.onProgress)
+                    options.onProgress(finished, m3u8Info.tsCount, info);
+                if (finished === m3u8Info.tsCount) {
+                    pool.close();
+                    barrier.open();
+                }
+                if (options.play && finished === playStart) {
+                    (0, local_play_1.localPlay)(m3u8Info.data, options);
+                }
+            });
+        }
+        await barrier.wait();
+        if (stats.tsFailed === 0) {
+            result.filepath = await (0, m3u8_convert_1.m3u8Convert)(options, m3u8Info.data);
+            if ((0, node_fs_1.existsSync)(options.cacheDir) && options.delCache)
+                (0, fe_utils_1.rmrf)(options.cacheDir);
+        }
+        else
+            utils_1.logger.debug('Download Failed! Please retry!', stats.tsFailed);
+    }
+    utils_1.logger.debug('Done!', url, result.m3u8Info);
+    return result;
+}
+exports.m3u8Download = m3u8Download;

package/cjs/lib/parseM3u8.d.ts

@@ -0,0 +1,11 @@
+import type { M3u8Crypto, TsItemInfo } from '../type';
+export declare function parseM3U8(content: string, url?: string, cacheDir?: string): Promise<{
+    manifest: any;
+    /** ts 文件数量 */
+    tsCount: number;
+    /** 总时长 */
+    durationSecond: number;
+    data: TsItemInfo[];
+    /** 加密相关信息 */
+    crypto: M3u8Crypto;
+}>;

package/cjs/lib/parseM3u8.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseM3U8 = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const m3u8_parser_1 = require("m3u8-parser");
+const utils_1 = require("./utils");
+async function parseM3U8(content, url = process.cwd(), cacheDir = './cache') {
+    if (!content && url) {
+        if (!url.startsWith('http') && (0, node_fs_1.existsSync)(url)) {
+            url = (0, node_path_1.resolve)(process.cwd(), url);
+            content = await node_fs_1.promises.readFile(url, 'utf8');
+        }
+        else {
+            content = (await (0, utils_1.getRetry)(url)).data;
+        }
+    }
+    utils_1.logger.debug('starting parsing m3u8 file:', url);
+    let parser = new m3u8_parser_1.Parser();
+    parser.push(content);
+    parser.end();
+    if (parser.manifest.playlists?.length > 0) {
+        url = new URL(url, parser.manifest.playlists[0].uri).toString();
+        content = (await (0, utils_1.getRetry)(url)).data;
+        parser = new m3u8_parser_1.Parser();
+        parser.push(content);
+        parser.end();
+    }
+    const tsList = parser.manifest.segments || [];
+    const result = {
+        manifest: parser.manifest,
+        /** ts 文件数量 */
+        tsCount: tsList.length,
+        /** 总时长 */
+        durationSecond: 0,
+        data: [],
+        /** 加密相关信息 */
+        crypto: {
+            method: 'AES-128',
+            iv: new Uint8Array(16),
+            key: '',
+            uri: '',
+        },
+    };
+    if (!result.tsCount) {
+        utils_1.logger.error('m3u8 file error!\n', url, content);
+        return result;
+    }
+    const tsKeyInfo = tsList[0].key;
+    if (tsKeyInfo?.uri) {
+        if (tsKeyInfo.method)
+            result.crypto.method = tsKeyInfo.method.toUpperCase();
+        if (tsKeyInfo.iv)
+            result.crypto.iv = new Uint8Array(Buffer.from(tsKeyInfo.iv));
+        result.crypto.uri = tsKeyInfo.uri.includes('://') ? tsKeyInfo.uri : new URL(tsKeyInfo.uri, url).toString();
+    }
+    if (result.crypto.uri !== '') {
+        const r = await (0, utils_1.getRetry)(result.crypto.uri);
+        result.crypto.key = r.buffer;
+    }
+    for (let i = 0; i < result.tsCount; i++) {
+        if (!tsList[i].uri.startsWith('http'))
+            tsList[i].uri = new URL(tsList[i].uri, url).toString();
+        result.data.push({
+            index: i,
+            duration: tsList[i].duration,
+            timeline: tsList[i].timeline,
+            uri: tsList[i].uri,
+            tsOut: `${cacheDir}/${i}-${(0, node_path_1.basename)(tsList[i].uri).replace(/\.ts\?.+/, '.ts')}`,
+        });
+        result.durationSecond += tsList[i].duration;
+    }
+    return result;
+}
+exports.parseM3U8 = parseM3U8;
+// parseM3U8('', 't.m3u8').then(d => console.log(d));

package/cjs/lib/ts-download.d.ts

@@ -0,0 +1,2 @@
+import type { M3u8Crypto, TsItemInfo } from '../type';
+export declare function tsDownload(info: TsItemInfo, cryptoInfo: M3u8Crypto): Promise<boolean>;

package/cjs/lib/ts-download.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsDownload = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_worker_threads_1 = require("node:worker_threads");
+const utils_1 = require("./utils");
+async function tsDownload(info, cryptoInfo) {
+    try {
+        if ((0, node_fs_1.existsSync)(info.tsOut))
+            return true;
+        const r = await (0, utils_1.getRetry)(info.uri);
+        if (r.response.statusCode === 200) {
+            utils_1.logger.debug('\n', info);
+            const data = cryptoInfo.key ? aesDecrypt(r.buffer, cryptoInfo) : r.buffer;
+            await node_fs_1.promises.writeFile(info.tsOut, data);
+            return true;
+        }
+        utils_1.logger.warn('[TS-Download][failed]', r.response.statusCode, info.uri);
+    }
+    catch (e) {
+        utils_1.logger.error('[TS-Download][error]', e.message || e);
+    }
+    return false;
+}
+exports.tsDownload = tsDownload;
+function aesDecrypt(data, cryptoInfo) {
+    const decipher = (0, node_crypto_1.createDecipheriv)((cryptoInfo.method + '-cbc').toLocaleLowerCase(), cryptoInfo.key, cryptoInfo.iv);
+    return Buffer.concat([decipher.update(Buffer.isBuffer(data) ? data : Buffer.from(data)), decipher.final()]);
+}
+if (!node_worker_threads_1.isMainThread && node_worker_threads_1.parentPort) {
+    node_worker_threads_1.parentPort.on('message', (data) => {
+        if (data.options?.headers)
+            utils_1.request.setHeaders(data.options.headers);
+        tsDownload(data.info, data.crypto).then(success => {
+            data.info.success = success;
+            node_worker_threads_1.parentPort.postMessage({ success, info: data.info });
+        });
+    });
+}

package/cjs/lib/utils.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { NLogger, Request } from '@lzwme/fe-utils';
+export declare const request: Request;
+export declare const getRetry: <T = string>(url: string, retries?: number) => Promise<{
+    data: T;
+    buffer: Buffer;
+    headers: import("http").IncomingHttpHeaders;
+    response: import("http").IncomingMessage;
+}>;
+export declare const logger: NLogger;
+export declare function isSupportFfmpeg(): boolean;

package/cjs/lib/utils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSupportFfmpeg = exports.logger = exports.getRetry = exports.request = void 0;
+const fe_utils_1 = require("@lzwme/fe-utils");
+exports.request = new fe_utils_1.Request('', {
+    'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',
+});
+const getRetry = (url, retries = 3) => (0, fe_utils_1.retry)(() => exports.request.get(url), 1000, retries, r => r.response.statusCode === 200);
+exports.getRetry = getRetry;
+exports.logger = fe_utils_1.NLogger.getLogger('[M3U8-DL]', { color: fe_utils_1.color });
+let _isSupportFfmpeg = null;
+function isSupportFfmpeg() {
+    if (null == _isSupportFfmpeg)
+        _isSupportFfmpeg = (0, fe_utils_1.execSync)('ffmpeg -version').stderr === '';
+    return _isSupportFfmpeg;
+}
+exports.isSupportFfmpeg = isSupportFfmpeg;

package/cjs/lib/worker_pool.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="node" />
+import { EventEmitter } from 'node:events';
+export declare class WorkerPool<T = unknown, R = unknown> extends EventEmitter {
+    private processorFile;
+    numThreads: number;
+    private workers;
+    private freeWorkers;
+    private workerTaskInfo;
+    private tasks;
+    constructor(processorFile: string, numThreads?: number);
+    addNewWorker(processorFile?: string): void;
+    runTask(task: T, callback: (err: Error | null, result: R) => void): void;
+    close(): void;
+}

package/cjs/lib/worker_pool.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkerPool = void 0;
+const node_events_1 = require("node:events");
+const node_async_hooks_1 = require("node:async_hooks");
+const node_worker_threads_1 = require("node:worker_threads");
+const node_os_1 = require("node:os");
+const node_fs_1 = require("node:fs");
+const kWorkerFreedEvent = Symbol('kWorkerFreedEvent');
+class WorkerPoolTaskInfo extends node_async_hooks_1.AsyncResource {
+    callback;
+    constructor(callback) {
+        super('WorkerPoolTaskInfo');
+        this.callback = callback;
+        this.callback = callback;
+    }
+    done(err, result) {
+        this.runInAsyncScope(this.callback, null, err, result);
+        this.emitDestroy();
+    }
+}
+class WorkerPool extends node_events_1.EventEmitter {
+    processorFile;
+    numThreads;
+    workers = [];
+    freeWorkers = [];
+    workerTaskInfo = new Map();
+    tasks = [];
+    constructor(processorFile, numThreads = 0) {
+        super();
+        this.processorFile = processorFile;
+        this.numThreads = numThreads;
+        numThreads = +numThreads || (0, node_os_1.cpus)().length;
+        for (let i = 0; i < numThreads; i++)
+            this.addNewWorker(processorFile);
+        // 每当发出 kWorkerFreedEvent 时，调度队列中待处理的下一个任务（如果有）。
+        this.on(kWorkerFreedEvent, () => {
+            if (this.tasks.length > 0) {
+                const item = this.tasks.shift();
+                if (item)
+                    this.runTask(item.task, item.callback);
+            }
+        });
+    }
+    addNewWorker(processorFile = this.processorFile) {
+        if (!(0, node_fs_1.existsSync)(processorFile)) {
+            throw Error(`Not Found: ${processorFile}`);
+        }
+        const worker = new node_worker_threads_1.Worker(processorFile);
+        worker.on('message', (result) => {
+            // 如果成功：调用传递给`runTask`的回调，删除与Worker关联的`TaskInfo`，并再次将其标记为空闲。
+            const r = this.workerTaskInfo.get(worker);
+            if (r) {
+                r.done(null, result);
+                this.workerTaskInfo.delete(worker);
+                this.freeWorkers.push(worker);
+                this.emit(kWorkerFreedEvent);
+            }
+        });
+        worker.on('error', err => {
+            // 如果发生未捕获的异常：调用传递给 `runTask` 并出现错误的回调。
+            const r = this.workerTaskInfo.get(worker);
+            if (r) {
+                r.done(err, null);
+                this.workerTaskInfo.delete(worker);
+            }
+            else
+                this.emit('error', err);
+            // 从列表中删除 Worker 并启动一个新的 Worker 来替换当前的 Worker
+            this.workers.splice(this.workers.indexOf(worker), 1);
+            this.addNewWorker();
+        });
+        this.workers.push(worker);
+        this.freeWorkers.push(worker);
+        this.emit(kWorkerFreedEvent);
+    }
+    runTask(task, callback) {
+        if (this.freeWorkers.length === 0) {
+            this.tasks.push({ task, callback });
+            return;
+        }
+        const worker = this.freeWorkers.pop();
+        if (worker) {
+            this.workerTaskInfo.set(worker, new WorkerPoolTaskInfo(callback));
+            worker.postMessage(task);
+        }
+    }
+    close() {
+        for (const worker of this.workers)
+            worker.terminate();
+    }
+}
+exports.WorkerPool = WorkerPool;

package/cjs/m3u8-batch-download.d.ts

@@ -0,0 +1,2 @@
+import { M3u8DLOptions } from './type';
+export declare function m3u8BatchDownload(urls: string[], options: M3u8DLOptions): Promise<void>;

package/cjs/m3u8-batch-download.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.m3u8BatchDownload = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const m3u8_download_1 = require("./lib/m3u8-download");
+async function m3u8BatchDownload(urls, options) {
+    for (const url of urls) {
+        if ((0, node_fs_1.existsSync)(url)) {
+            const content = await node_fs_1.promises.readFile(url, 'utf8');
+            if (content.includes('.m3u8')) {
+                const list = content
+                    .split('\n')
+                    .filter(d => d.includes('.m3u8'))
+                    .map((href, idx) => {
+                    if (href.startsWith('http'))
+                        href = `${idx}|${href}`;
+                    return href;
+                });
+                if (!options.filename)
+                    options.filename = (0, node_path_1.basename)(url).split('.')[0];
+                await m3u8BatchDownload(list, options);
+                continue;
+            }
+        }
+        await (0, m3u8_download_1.m3u8Download)(url, options);
+    }
+}
+exports.m3u8BatchDownload = m3u8BatchDownload;

package/cjs/type.d.ts

@@ -0,0 +1,54 @@
+/// <reference path="../global.d.ts" />
+/// <reference types="node" />
+/// <reference types="node" />
+import type { IncomingHttpHeaders } from 'node:http';
+export interface TsItemInfo {
+    /** ts 文件次序 */
+    index: number;
+    duration: number;
+    timeline: number;
+    /** ts 文件下载 url 地址 */
+    uri: string;
+    /** ts 文件下载保存路径 */
+    tsOut: string;
+    /** 是否下载成功 */
+    success?: boolean;
+}
+export interface M3u8Crypto {
+    /** AES 加密 IV */
+    iv: NodeJS.ArrayBufferView | string;
+    /** 获取到的密钥值(hex) */
+    key: string | NodeJS.ArrayBufferView;
+    /** 加密方法 */
+    method: string;
+    /** 密钥获取接口 */
+    uri: string;
+}
+export interface M3u8DLOptions {
+    debug?: boolean;
+    /** 是否显示内置的进度信息。默认为 true */
+    showProgress?: boolean;
+    /** 每当 ts 文件下载完成时回调，可用于自定义进度控制 */
+    onProgress?: (finished: number, total: number, currentInfo: TsItemInfo) => void;
+    /** 并发下载线程数。取决于服务器限制，过多可能会容易下载失败。一般建议不超过 4 个。默认为 cpu 数量 */
+    threadNum?: number;
+    /** 要保存的文件名(路径) */
+    filename?: string;
+    /** 下载文件保存的路径。默认为当前目录 */
+    saveDir?: string;
+    /** 临时文件保存目录。默认为 cache/<md5(url)> */
+    cacheDir?: string;
+    /** 下载成功后是否删除临时文件。默认为 true。保存临时文件可以在重复下载时识别缓存 */
+    delCache?: boolean;
+    /** 文件已存在时是否仍强制下载和生成。默认为 false，文件已存在则跳过 */
+    force?: boolean;
+    /** 下载 m3u8、ts 等文件时自定义请求 headers */
+    headers?: IncomingHttpHeaders;
+    /** 下载时是否启动本地资源播放（边下边看） */
+    play?: boolean;
+}
+export interface WorkerTaskInfo {
+    info: TsItemInfo;
+    crypto: M3u8Crypto;
+    options: M3u8DLOptions;
+}

package/global.d.ts

@@ -0,0 +1 @@
+declare module 'm3u8-parser';

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@lzwme/m3u8-dl",
+  "version": "0.0.1",
+  "description": "Batch download of m3u8 files and convert to mp4",
+  "main": "cjs/index.js",
+  "types": "cjs/index.d.ts",
+  "license": "MIT",
+  "repository": "https://github.com/lzwme/m3u8-dl.git",
+  "author": {
+    "name": "renxia",
+    "email": "lzwy0820@qq.com",
+    "url": "https://lzw.me"
+  },
+  "scripts": {
+    "prepare": "husky install",
+    "dev": "npm run watch",
+    "watch": "npm run build -- -- -w",
+    "lint": "flh --eslint --tscheck --prettier",
+    "build": "npm run clean && npm run build:cjs",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "doc": "typedoc src/ --exclude **/*.spec.ts --out docs --tsconfig tsconfig.module.json",
+    "version": "standard-version",
+    "dist": "npm run build",
+    "release": "npm run dist && npm run version",
+    "clean": "flh rm -f ./cjs ./esm ./docs",
+    "test": "npm run lint"
+  },
+  "bin": {
+    "m3u8dl": "bin/m3u8dl.js"
+  },
+  "keywords": [
+    "m3u8-download",
+    "m3u8",
+    "mp4",
+    "download",
+    "ffmpeg"
+  ],
+  "packageManager": "pnpm@7.6.0",
+  "engines": {
+    "node": ">=14.18"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.com"
+  },
+  "devDependencies": {
+    "@lzwme/fed-lint-helper": "^2.2.0",
+    "@types/node": "^18.11.18",
+    "@typescript-eslint/eslint-plugin": "^5.49.0",
+    "@typescript-eslint/parser": "^5.49.0",
+    "eslint": "^8.32.0",
+    "eslint-config-prettier": "^8.6.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "husky": "^8.0.3",
+    "prettier": "^2.8.3",
+    "standard-version": "^9.5.0",
+    "typescript": "^4.9.4"
+  },
+  "dependencies": {
+    "@lzwme/fe-utils": "^1.3.3",
+    "commander": "^10.0.0",
+    "console-log-colors": "^0.3.3",
+    "m3u8-parser": "^6.0.0"
+  },
+  "files": [
+    "cjs",
+    "!cjs/type.js",
+    "!cjs/cli.d.ts",
+    "global.d.ts",
+    "bin"
+  ]
+}