koishi-plugin-kkk 1.0.0

package/lib/karin/platform/douyin/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDouyinWorkDetail = void 0;
+/**
+ * 把 amagi 返回的 aweme 对象装配成渲染/推送使用的作品详情。
+ * amagi 的生成类型在 text_extra（实为对象数组）、images（图文作品实为数组）等字段上
+ * 与真实数据不符，统一在这一处边界断言，下游全部享受精确类型。
+ * 返回类型会带上 extra 的实际形状，例如传入 user_info 后下游可把它当作必填字段使用。
+ * @param aweme - amagi 返回的作品详情（aweme_detail 或作品列表项）
+ * @param extra - 流程附加字段（作者/订阅者主页信息）
+ */
+const buildDouyinWorkDetail = (aweme, extra = {}) => ({ ...aweme, ...extra });
+exports.buildDouyinWorkDetail = buildDouyinWorkDetail;

package/lib/karin/platform/douyin/videoQuality.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.douyinProcessVideos = exports.formatDouyinQualityLabel = exports.buildDouyinPlayUrl = exports.getDouyinQualityLevel = void 0;
+const node_karin_1 = require("../../../compat/node-karin.js");
+const Config_1 = require("../../module/utils/Config");
+/** 档位优先级，从高到低 */
+const QUALITY_PRIORITY = ['4k', '2k', '1080p', '720p', '540p'];
+/**
+ * `video_extra.definition` → 内部档位名。
+ * 抖音上游把 2K 记作 `1440p`，而配置项 `videoQuality` 用的是 `2k`，
+ * 这张表是两套词表唯一的翻译点，配置域不需要跟着上游改。
+ */
+const DEFINITION_TO_LEVEL = {
+    '4k': '4k',
+    '2k': '2k',
+    '1440p': '2k',
+    '1080p': '1080p',
+    '720p': '720p',
+    '540p': '540p'
+};
+/** 档位 → 展示标签，沿用抖音 Web 端播放器的说法 */
+const QUALITY_LABEL = {
+    '4k': '超清4K',
+    '2k': '超清2K',
+    '1080p': '高清1080P',
+    '720p': '高清720P',
+    '540p': '标清540P'
+};
+/**
+ * 安全解析 `video_extra`
+ * @param extra - 原始 JSON 字符串
+ * @returns 解析结果，为空或非法 JSON 时返回 null
+ */
+const parseVideoExtra = (extra) => {
+    if (!extra)
+        return null;
+    try {
+        return JSON.parse(extra);
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * 从 `gear_name` 猜测档位。
+ * 只作为 `video_extra.definition` 缺失时的兜底：抖音随时可能新增 gear_name，
+ * 认不出来就返回 undefined 交给调用方处理，不再默认落到 540p 污染分档。
+ * @param gearName - 视频源的 gear_name
+ * @returns 档位名，认不出时返回 undefined
+ */
+const guessLevelFromGearName = (gearName) => {
+    if (gearName.includes('lowest_4') || gearName.includes('2160'))
+        return '4k';
+    if (gearName.includes('1440') || gearName.includes('2k'))
+        return '2k';
+    if (gearName.includes('1080'))
+        return '1080p';
+    if (gearName.includes('720'))
+        return '720p';
+    if (gearName.includes('540'))
+        return '540p';
+    return undefined;
+};
+/**
+ * 判定单个视频源的清晰度档位。
+ * `video_extra.definition` 是唯一可信来源：抖音视频比例不固定（存在 21:9、1:1 等），
+ * 一个 3840x1608 的视频不满足 3840x2160 但官方仍定义为 4K，所以不能拿 play_addr 的宽高硬匹配。
+ * @param video - 视频源对象
+ * @returns 档位名，无法判定时返回 undefined
+ */
+const getDouyinQualityLevel = (video) => {
+    const definition = parseVideoExtra(video.video_extra)?.definition;
+    const level = definition ? DEFINITION_TO_LEVEL[definition] : undefined;
+    return level ?? guessLevelFromGearName(video.gear_name ?? '');
+};
+exports.getDouyinQualityLevel = getDouyinQualityLevel;
+/**
+ * 同档位内的取源顺序：先 H.264，再按体积从大到小。
+ * 1080p / 720p 的 H.265（ByteVC1）在部分协议端软解失败，同档位下 H.264 更稳；
+ * 4K / 2K 上游通常只提供 H.265，此时全组同权重，自然退化为按体积排序。
+ * @param a - 视频源 A
+ * @param b - 视频源 B
+ * @returns 排序比较值
+ */
+const compareVideoPreference = (a, b) => {
+    if (a.is_bytevc1 !== b.is_bytevc1)
+        return a.is_bytevc1 - b.is_bytevc1;
+    return b.play_addr.data_size - a.play_addr.data_size;
+};
+/**
+ * 按档位给 mp4 视频源分组，组内已按 {@link compareVideoPreference} 排好序
+ * @param videos - 视频源数组
+ * @returns 档位 → 该档位下的视频源
+ */
+const groupByQualityLevel = (videos) => {
+    const grouped = new Map();
+    for (const video of videos) {
+        const level = (0, exports.getDouyinQualityLevel)(video);
+        if (!level) {
+            node_karin_1.logger.debug(`无法判定清晰度档位，跳过该视频源：gear_name=${video.gear_name}`);
+            continue;
+        }
+        const bucket = grouped.get(level);
+        if (bucket) {
+            bucket.push(video);
+        }
+        else {
+            grouped.set(level, [video]);
+        }
+    }
+    grouped.forEach((bucket) => bucket.sort(compareVideoPreference));
+    return grouped;
+};
+/**
+ * 构建抖音视频播放地址（二维码分享链接与下载共用）。
+ * 上游 play 接口现在除 video_id 外还要求携带 file_id（从 play_addr.url_list[2] 的查询参数中提取），
+ * 旧的 ratio/line 参数不再需要；file_id 提取失败时回退为仅带 video_id。
+ * @param playAddr - 视频源的 play_addr 对象（bit_rate 项或 images 项的 play_addr_h264）
+ * @returns 完整的播放地址
+ */
+const buildDouyinPlayUrl = (playAddr) => {
+    const fileId = (() => {
+        try {
+            const wrappedUrl = playAddr.url_list?.[2];
+            return wrappedUrl ? new URL(wrappedUrl).searchParams.get('file_id') : null;
+        }
+        catch {
+            return null;
+        }
+    })();
+    return fileId
+        ? `https://aweme.snssdk.com/aweme/v1/play/?video_id=${playAddr.uri}&file_id=${fileId}`
+        : `https://aweme.snssdk.com/aweme/v1/play/?video_id=${playAddr.uri}`;
+};
+exports.buildDouyinPlayUrl = buildDouyinPlayUrl;
+/**
+ * 把选中的视频源格式化成展示用的清晰度字符串。
+ * 传入的必须是 {@link douyinProcessVideos} 选中的那一路源 —— 卡片上展示的清晰度要和实际下载的一致，
+ * 否则会出现「卡片写 4K、实际下载 720p」的错位。
+ * @param video - 选中的视频源
+ * @returns 形如 `超清4K`；档位认不出时返回空字符串
+ */
+const formatDouyinQualityLabel = (video) => {
+    if (!video)
+        return '';
+    const level = (0, exports.getDouyinQualityLevel)(video);
+    if (!level)
+        return '';
+    return QUALITY_LABEL[level];
+};
+exports.formatDouyinQualityLabel = formatDouyinQualityLabel;
+/**
+ * 按画质偏好从抖音视频源列表里挑出唯一一路可下载的源
+ * @param videos - `aweme_detail.video.bit_rate` 数组
+ * @param videoQuality - 画质偏好，`adapt` 为按体积上限自动选择，其余为固定档位
+ * @param maxAutoVideoSize - 自动模式下可接受的最大体积（MB），缺省回落到 `Config.app.filelimit`
+ * @returns 长度为 1 的数组，元素为选中的视频源
+ */
+const douyinProcessVideos = (videos, videoQuality, maxAutoVideoSize) => {
+    // Web 端与下载都只认 mp4 封装，dash 是 App 端流媒体专用
+    const mp4Videos = videos.filter((video) => video.format === 'mp4');
+    if (mp4Videos.length === 0) {
+        node_karin_1.logger.warn('没有找到可用的 mp4 格式视频');
+        return videos.slice(0, 1); // 返回第一个视频作为备选
+    }
+    node_karin_1.logger.debug(`过滤后剩余 ${mp4Videos.length} 个 mp4 格式视频`);
+    const videosByQuality = groupByQualityLevel(mp4Videos);
+    // 如果是自动模式
+    if (videoQuality === 'adapt') {
+        const sizeLimitBytes = (maxAutoVideoSize || Config_1.Config.app.filelimit) * 1024 * 1024;
+        for (const quality of QUALITY_PRIORITY) {
+            const qualityVideos = videosByQuality.get(quality);
+            if (qualityVideos && qualityVideos.length > 0) {
+                // 该档位下第一个不超过体积上限的源（组内已按 H.264 优先、体积从大到小排序）
+                const suitableVideo = qualityVideos.find((video) => video.play_addr.data_size <= sizeLimitBytes);
+                if (suitableVideo) {
+                    node_karin_1.logger.debug(`自动选择画质: ${quality}, 文件大小: ${(suitableVideo.play_addr.data_size / (1024 * 1024)).toFixed(2)}MB`);
+                    return [suitableVideo];
+                }
+            }
+        }
+        // 如果没有找到符合大小限制的视频，选择最小的视频
+        let smallestVideo = mp4Videos[0];
+        mp4Videos.forEach((video) => {
+            if (video.play_addr.data_size < smallestVideo.play_addr.data_size) {
+                smallestVideo = video;
+            }
+        });
+        node_karin_1.logger.debug(`未找到符合大小限制的视频，选择最小视频: ${(smallestVideo.play_addr.data_size / (1024 * 1024)).toFixed(2)}MB`);
+        return [smallestVideo];
+    }
+    // 固定画质模式
+    const targetQuality = videoQuality;
+    const targetVideos = videosByQuality.get(targetQuality);
+    if (targetVideos && targetVideos.length > 0) {
+        // 选择该画质下最优的视频源
+        node_karin_1.logger.debug(`选择固定画质: ${targetQuality}, 文件大小: ${(targetVideos[0].play_addr.data_size / (1024 * 1024)).toFixed(2)}MB`);
+        return [targetVideos[0]];
+    }
+    // 如果没有找到目标画质，选择最接近的画质
+    const targetIndex = QUALITY_PRIORITY.indexOf(targetQuality);
+    // 先尝试向下找（更低画质）
+    for (let i = targetIndex + 1; i < QUALITY_PRIORITY.length; i++) {
+        const fallbackVideos = videosByQuality.get(QUALITY_PRIORITY[i]);
+        if (fallbackVideos && fallbackVideos.length > 0) {
+            node_karin_1.logger.debug(`目标画质 ${targetQuality} 不可用，降级到: ${QUALITY_PRIORITY[i]}`);
+            return [fallbackVideos[0]];
+        }
+    }
+    // 再尝试向上找（更高画质）
+    for (let i = targetIndex - 1; i >= 0; i--) {
+        const fallbackVideos = videosByQuality.get(QUALITY_PRIORITY[i]);
+        if (fallbackVideos && fallbackVideos.length > 0) {
+            node_karin_1.logger.debug(`目标画质 ${targetQuality} 不可用，升级到: ${QUALITY_PRIORITY[i]}`);
+            return [fallbackVideos[0]];
+        }
+    }
+    // 如果都没找到，返回第一个可用视频
+    node_karin_1.logger.warn('未找到任何匹配的画质，返回默认视频');
+    return [mp4Videos[0]];
+};
+exports.douyinProcessVideos = douyinProcessVideos;

package/lib/karin/platform/douyin/workType.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DouyinImageSubType = exports.DouyinWorkMainType = void 0;
+exports.getWorkTypeFromUrl = getWorkTypeFromUrl;
+exports.getWorkTypeInfo = getWorkTypeInfo;
+exports.getWorkCoverUrl = getWorkCoverUrl;
+exports.getWorkTypeDisplayName = getWorkTypeDisplayName;
+exports.needsSpecialImageProcessing = needsSpecialImageProcessing;
+exports.getDouyinLiveImageSendPolicy = getDouyinLiveImageSendPolicy;
+/**
+ * 抖音作品类型工具模块
+ * 提供统一的作品类型判断和处理逻辑
+ */
+/**
+ * 抖音作品主类型
+ */
+var DouyinWorkMainType;
+(function (DouyinWorkMainType) {
+    /** 视频作品 */
+    DouyinWorkMainType["VIDEO"] = "video";
+    /** 图文作品（包含图集和合辑） */
+    DouyinWorkMainType["IMAGE"] = "image";
+    /** 文章作品 */
+    DouyinWorkMainType["ARTICLE"] = "article";
+    /** 直播 */
+    DouyinWorkMainType["LIVE"] = "live";
+    /** 音乐 */
+    DouyinWorkMainType["MUSIC"] = "music";
+    /** 未知类型 */
+    DouyinWorkMainType["UNKNOWN"] = "unknown";
+})(DouyinWorkMainType || (exports.DouyinWorkMainType = DouyinWorkMainType = {}));
+/**
+ * 图文作品子类型
+ */
+var DouyinImageSubType;
+(function (DouyinImageSubType) {
+    /** 图集（纯静态图片或包含 live 图） */
+    DouyinImageSubType["GALLERY"] = "gallery";
+    /** 合辑（图片+视频混合） */
+    DouyinImageSubType["COLLECTION"] = "collection";
+})(DouyinImageSubType || (exports.DouyinImageSubType = DouyinImageSubType = {}));
+/**
+ * 从 URL 路径判断作品类型
+ */
+function getWorkTypeFromUrl(url) {
+    if (/\/video\//.test(url))
+        return DouyinWorkMainType.VIDEO;
+    if (/\/note\//.test(url))
+        return DouyinWorkMainType.IMAGE;
+    if (/\/article\//.test(url))
+        return DouyinWorkMainType.ARTICLE;
+    if (/live\.douyin\.com/.test(url) || /webcast\.amemv\.com/.test(url))
+        return DouyinWorkMainType.LIVE;
+    if (/\/music\//.test(url))
+        return DouyinWorkMainType.MUSIC;
+    return DouyinWorkMainType.UNKNOWN;
+}
+/**
+ * 从作品数据判断详细类型信息
+ */
+function getWorkTypeInfo(data) {
+    // 直播类型（有 live_data 对象）
+    if (data.live_data) {
+        return {
+            mainType: DouyinWorkMainType.LIVE,
+            isVideo: false,
+            isImage: false,
+            isArticle: false,
+            isLive: true,
+            isGallery: false,
+            isCollection: false,
+            templatePath: 'douyin/live'
+        };
+    }
+    // 文章类型（aweme_type === 163）
+    if (data.aweme_type === 163 || data.article_info) {
+        return {
+            mainType: DouyinWorkMainType.ARTICLE,
+            isVideo: false,
+            isImage: false,
+            isArticle: true,
+            isLive: false,
+            isGallery: false,
+            isCollection: false,
+            templatePath: 'douyin/article-work'
+        };
+    }
+    // 图文类型（有 images 数组）
+    if (data.images && data.images.length > 0) {
+        const subType = data.is_slides === true ? DouyinImageSubType.COLLECTION : DouyinImageSubType.GALLERY;
+        return {
+            mainType: DouyinWorkMainType.IMAGE,
+            subType,
+            isVideo: false,
+            isImage: true,
+            isArticle: false,
+            isLive: false,
+            isGallery: subType === DouyinImageSubType.GALLERY,
+            isCollection: subType === DouyinImageSubType.COLLECTION,
+            templatePath: 'douyin/image-work'
+        };
+    }
+    // 视频类型（默认）
+    return {
+        mainType: DouyinWorkMainType.VIDEO,
+        isVideo: true,
+        isImage: false,
+        isArticle: false,
+        isLive: false,
+        isGallery: false,
+        isCollection: false,
+        templatePath: 'douyin/video-work'
+    };
+}
+/** 抖音图床低分辨率处理模板（如 ~tplv-dy-360p.jpeg），命中说明该封面 URL 被 CDN 降质 */
+const LOW_RES_COVER_PATTERN = /~tplv-[^/?]*(?:270p|360p|480p|540p)/i;
+/**
+ * 获取作品封面 URL
+ */
+function getWorkCoverUrl(workTypeInfo, data) {
+    // 视频封面
+    if (workTypeInfo.isVideo && data.video) {
+        // 详情接口没有 animated_cover，会落到 cover_original_scale，
+        // 而它的 url_list[0] 常是 ~tplv-dy-360p 这类 CDN 降质模板（签名绑定路径，无法改 URL 还原）。
+        // 所以按优先级收集所有候选后，优先取未命中低清模板的；全部命中时维持原优先级兜底。
+        const candidates = [data.video.animated_cover, data.video.cover_original_scale, data.video.origin_cover, data.video.cover].flatMap((field) => field?.url_list ?? []);
+        return candidates.find((url) => !LOW_RES_COVER_PATTERN.test(url)) ?? candidates[0] ?? '';
+    }
+    // 图文封面
+    if (workTypeInfo.isImage && data.images && data.images.length > 0) {
+        return data.images[0].url_list[0] ?? '';
+    }
+    // 文章封面
+    if (workTypeInfo.isArticle && data.article_info?.article_content) {
+        try {
+            const content = JSON.parse(data.article_info.article_content);
+            return content.head_poster_list?.url_list?.[0] ?? '';
+        }
+        catch {
+            return '';
+        }
+    }
+    return '';
+}
+/**
+ * 获取作品类型的显示名称
+ */
+function getWorkTypeDisplayName(workTypeInfo) {
+    if (workTypeInfo.isVideo)
+        return '视频';
+    if (workTypeInfo.isGallery)
+        return '图集';
+    if (workTypeInfo.isCollection)
+        return '合辑';
+    if (workTypeInfo.isArticle)
+        return '文章';
+    if (workTypeInfo.isLive)
+        return '直播';
+    return '未知';
+}
+/**
+ * 判断是否需要特殊处理（如 live 图）
+ */
+function needsSpecialImageProcessing(workTypeInfo, images) {
+    if (!workTypeInfo.isImage || !images)
+        return false;
+    // 检查是否包含 live 图（clip_type !== 2）
+    return images.some((item) => item.clip_type !== 2 && item.clip_type !== undefined);
+}
+/**
+ * 抖音图文里的 clip_type=5 才能生成系统实况图；clip_type=4 是短片。
+ * 用户选择仅发送实况图时，短片仍需兜底成视频节点，避免生成空合并转发。
+ */
+function getDouyinLiveImageSendPolicy(clipType, livePhotoMode = 'video_and_livephoto') {
+    const isStaticImage = clipType === 2 || clipType === undefined;
+    const canGenerateLivePhoto = clipType === 5;
+    const shouldFallbackToVideo = livePhotoMode === 'livephoto_only' && !isStaticImage && !canGenerateLivePhoto;
+    return {
+        shouldGenerateVideo: livePhotoMode === 'video_and_livephoto' || livePhotoMode === 'video_only' || shouldFallbackToVideo,
+        shouldGenerateLivePhoto: canGenerateLivePhoto && (livePhotoMode === 'video_and_livephoto' || livePhotoMode === 'livephoto_only')
+    };
+}

package/lib/karin/platform/index.js

@@ -0,0 +1,20 @@
+"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("./bilibili"), exports);
+__exportStar(require("./douyin"), exports);
+__exportStar(require("./kuaishou"), exports);
+__exportStar(require("./xiaohongshu"), exports);

package/lib/karin/platform/kuaishou/comments.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kuaishouComments = void 0;
+const richtext_1 = require("../../../richtext");
+const Config_1 = require("../../module/utils/Config");
+/**
+ * 处理快手评论数据。
+ *
+ * 这里不再拼 HTML，而是输出共享富文本 JSON，交给 template 侧渲染 React 节点。
+ *
+ * amagi 把评论换到 H5 `photo/comment/list` 之后形状变了三处，且按「不归一化」原样透出：
+ * 条目从 `data.visionCommentList.rootComments` 提到顶层 `rootComments`、字段名从
+ * camelCase 变成 snake_case、子评论从内嵌的 `subComments` 挪到了 `subCommentsMap`。
+ * 本函数只用到根评论和 `subCommentCount` 这个计数，所以 `subCommentsMap` 暂不读。
+ */
+const kuaishouComments = async (data, emojiData) => {
+    const rootComments = data?.rootComments;
+    if (!Array.isArray(rootComments) || rootComments.length === 0) {
+        return [];
+    }
+    const comments = rootComments.map((comment) => ({
+        // 生成类型里 `comment_id` 是数字（H5 这条的 id 就是数字），模板侧要字符串
+        cid: String(comment.comment_id ?? ''),
+        aweme_id: String(comment.comment_id ?? ''),
+        nickname: comment.author_name ?? '',
+        userimageurl: comment.headurl ?? '',
+        text: buildKuaishouRichText(comment.content ?? '', emojiData),
+        // H5 这条**没有** `realLikedCount`（那是 PC GraphQL 独有的真实点赞数），只剩展示用的
+        // `likedCount`，还可能是「1.2万」这种字符串 —— 解不出数字就沿用原有的兜底值 0
+        digg_count: Number(comment.likedCount) || 0,
+        create_time: comment.timestamp ?? 0,
+        reply_comment_total: comment.subCommentCount ?? 0
+    }));
+    return comments.sort((a, b) => b.digg_count - a.digg_count).slice(0, Math.min(comments.length, Config_1.Config.kuaishou.numcomment));
+};
+exports.kuaishouComments = kuaishouComments;
+/**
+ * 把快手评论正文解析成共享富文本 JSON。
+ *
+ * 当前主要兼容：
+ * - `[表情]` 形式的平台表情；
+ * - `@昵称(uid)` 形式的提及；
+ * - 评论里的换行与空格。
+ */
+const buildKuaishouRichText = (text, emojiData) => {
+    const normalizedText = typeof text === 'string' ? text : String(text || '');
+    const emojiTokens = [...emojiData].sort((a, b) => b.name.length - a.name.length);
+    const nodes = [];
+    let buffer = '';
+    let index = 0;
+    const pushBuffer = () => {
+        if (buffer.length > 0) {
+            nodes.push((0, richtext_1.createTextNode)(buffer));
+            buffer = '';
+        }
+    };
+    while (index < normalizedText.length) {
+        if (normalizedText[index] === '\r') {
+            pushBuffer();
+            index += normalizedText[index + 1] === '\n' ? 2 : 1;
+            nodes.push((0, richtext_1.createLineBreakNode)());
+            continue;
+        }
+        if (normalizedText[index] === '\n') {
+            pushBuffer();
+            nodes.push((0, richtext_1.createLineBreakNode)());
+            index += 1;
+            continue;
+        }
+        const mentionMatch = normalizedText.slice(index).match(/^@([^()]+?)\(([^)]+)\)/);
+        if (mentionMatch) {
+            pushBuffer();
+            const mentionText = `@${mentionMatch[1].trim()}`;
+            const mentionId = mentionMatch[2].trim() || undefined;
+            nodes.push((0, richtext_1.createMentionNode)(mentionText, mentionId));
+            index += mentionMatch[0].length;
+            continue;
+        }
+        const matchedEmoji = emojiTokens.find((item) => normalizedText.startsWith(item.name, index));
+        if (matchedEmoji) {
+            pushBuffer();
+            nodes.push((0, richtext_1.createEmojiNode)(matchedEmoji.name, matchedEmoji.url));
+            index += matchedEmoji.name.length;
+            continue;
+        }
+        buffer += normalizedText[index];
+        index += 1;
+    }
+    pushBuffer();
+    return (0, richtext_1.createRichTextDocument)(nodes, { platform: 'kuaishou' });
+};

package/lib/karin/platform/kuaishou/getID.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKuaishouID = void 0;
+const node_karin_1 = require("../../../compat/node-karin.js");
+const module_1 = require("../../module");
+/**
+ *
+ * @param url 分享链接
+ * @param log 输出日志，默认true
+ * @returns
+ */
+const getKuaishouID = async (url, log = true) => {
+    const longLink = await new module_1.Networks({ url }).getLongLink();
+    let result = {};
+    switch (true) {
+        case /photoId=(.*)/.test(longLink): {
+            const workid = /photoId=([^&]+)/.exec(longLink);
+            result = {
+                type: 'one_work',
+                photoId: workid ? workid[1] : undefined
+            };
+            break;
+        }
+        // 匹配 kuaishou.com/short-video/{id} 格式的链接
+        case /kuaishou\.com\/short-video\/([^?]+)/.test(longLink): {
+            const workid = /short-video\/([^?]+)/.exec(longLink);
+            result = {
+                type: 'one_work',
+                photoId: workid ? workid[1] : undefined
+            };
+            break;
+        }
+        default: {
+            node_karin_1.logger.warn('无法获取作品ID');
+            break;
+        }
+    }
+    if (log) {
+        console.log(result);
+    }
+    return result;
+};
+exports.getKuaishouID = getKuaishouID;

package/lib/karin/platform/kuaishou/getdata.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchKuaishouData = void 0;
+const amagiClient_1 = require("../../module/utils/amagiClient");
+/**
+ * 按数据类型取快手数据。
+ *
+ * 返回类型必须显式写出来：不写的话 TS 推出的是生成树的底层名（`Comments_V0` 这类），
+ * 而那些名字不出现在包外 —— 声明产物于是报 TS2883「inferred type cannot be named」。
+ * @param type - 数据类型
+ * @param opt - 该类型对应的参数（调用方是链接解析结果，字段随链接类型变化）
+ * @returns 按 type 分支的响应体
+ */
+const fetchKuaishouData = async (type, opt) => {
+    switch (type) {
+        case 'one_work': {
+            const VideoData = await amagiClient_1.kuaishouFetcher.fetchVideoWork({
+                photoId: opt.photoId
+            });
+            const CommentsData = await amagiClient_1.kuaishouFetcher.fetchWorkComments({
+                photoId: opt.photoId
+            });
+            const EmojiData = await amagiClient_1.kuaishouFetcher.fetchEmojiList();
+            return { VideoData: VideoData.data, CommentsData: CommentsData.data, EmojiData: EmojiData.data };
+        }
+        case 'work_comments': {
+            const CommentsData = await amagiClient_1.kuaishouFetcher.fetchWorkComments({
+                photoId: opt.photoId
+            });
+            return CommentsData.data;
+        }
+        case 'emoji_list': {
+            const EmojiData = await amagiClient_1.kuaishouFetcher.fetchEmojiList();
+            return EmojiData.data;
+        }
+        default: {
+            break;
+        }
+    }
+};
+exports.fetchKuaishouData = fetchKuaishouData;

package/lib/karin/platform/kuaishou/index.js

@@ -0,0 +1,20 @@
+"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("./comments"), exports);
+__exportStar(require("./getdata"), exports);
+__exportStar(require("./getID"), exports);
+__exportStar(require("./kuaishou"), exports);