@qcplay/cli 1.0.14 → 1.0.15

package/lib/content-rules.js

@@ -0,0 +1,807 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { createHash } from "crypto";
+import { inflateRawSync } from "zlib";
+
+import * as cheerio from "cheerio";
+
+const RULE_VERSION = 1;
+const RULE_ACTIONS = new Set([
+  "remove_section_until_next_heading",
+  "remove_section_to_end",
+  "remove_section_through_match",
+  "remove_text_block",
+  "replace_text",
+  "remove_image",
+  "replace_image",
+  "remove_image_caption"
+]);
+const MATCH_OPERATORS = new Set(["contains", "equals", "starts_with", "ends_with"]);
+const RULE_PHASES = new Set(["import", "publish", "*"]);
+const BLOCK_SELECTOR = "p,li,blockquote,figcaption,h1,h2,h3,h4,h5,h6,div,section,aside,footer";
+const PLATFORM_ALIASES = new Map([
+  ["官网", "website"],
+  ["website", "website"],
+  ["tap", "taptap"],
+  ["taptap", "taptap"],
+  ["b站", "bilibili"],
+  ["哔哩哔哩", "bilibili"],
+  ["bilibili", "bilibili"],
+  ["微博", "weibo"],
+  ["weibo", "weibo"],
+  ["好游快爆", "haoyou"],
+  ["haoyou", "haoyou"],
+  ["小红书", "xiaohongshu"],
+  ["xiaohongshu", "xiaohongshu"],
+  ["xhs", "xiaohongshu"],
+  ["discord", "discord"]
+]);
+
+export const DEFAULT_CONTENT_RULES_FILE = path.join(os.homedir(), ".qcplay", "platform-rules.json");
+
+export const CONTENT_RULES_TEMPLATE = {
+  version: RULE_VERSION,
+  rules: [
+    {
+      name: "公众号删除抽奖章节",
+      enabled: true,
+      source: "wechat",
+      project: "*",
+      platform: "*",
+      actions: [
+        {
+          type: "remove_section_until_next_heading",
+          match: { text: ["回复有奖", "评论抽奖"], operator: "contains" }
+        }
+      ]
+    },
+    {
+      name: "B站删除官充章节",
+      enabled: true,
+      source: "wechat",
+      project: "*",
+      platform: "bilibili",
+      actions: [
+        {
+          type: "remove_section_until_next_heading",
+          match: { text: "官充", operator: "contains" }
+        }
+      ]
+    },
+    {
+      name: "替换指定图片和文案",
+      enabled: false,
+      source: "*",
+      project: "示例游戏",
+      platform: "*",
+      actions: [
+        {
+          type: "replace_text",
+          match: { text: "旧文案", operator: "contains" },
+          replacement: "新文案"
+        },
+        {
+          type: "replace_image",
+          match: { src: "old-image.png", operator: "contains" },
+          replacement: { src: "https://example.com/new-image.png", alt: "新图片" }
+        }
+      ]
+    },
+    {
+      name: "公众号拉取时删除引导图片和文案",
+      enabled: false,
+      phase: "import",
+      source: "wechat",
+      project: "*",
+      platform: "*",
+      actions: [
+        {
+          type: "remove_image",
+          match: { nearby_text: ["长按识别", "关注公众号"], operator: "contains" }
+        },
+        {
+          type: "remove_text_block",
+          match: { text: ["长按识别", "关注公众号"], operator: "contains" }
+        }
+      ]
+    }
+  ]
+};
+
+function normalizeText(value) {
+  return String(value ?? "").trim();
+}
+
+function normalizeKey(value) {
+  return normalizeText(value).toLowerCase().replace(/\s+/g, "");
+}
+
+function canonicalPlatform(value) {
+  const key = normalizeKey(value);
+  return PLATFORM_ALIASES.get(key) || key;
+}
+
+function arrayValue(value) {
+  return Array.isArray(value) ? value : value === undefined || value === null ? [] : [value];
+}
+
+function ruleError(location, message) {
+  throw new Error(`内容规则 ${location}: ${message}`);
+}
+
+function validateScopeValue(value, location) {
+  if (value === undefined) return;
+  const values = arrayValue(value);
+  if (values.length === 0 || values.some(item => typeof item !== "string" || !item.trim())) {
+    ruleError(location, "必须是非空字符串或非空字符串数组");
+  }
+}
+
+function validateMatch(match, location, allowedFields) {
+  if (!match || typeof match !== "object" || Array.isArray(match)) {
+    ruleError(location, "match 必须是对象");
+  }
+  const fields = Object.keys(match).filter(field => field !== "operator" && field !== "case_sensitive");
+  if (fields.some(field => !allowedFields.has(field))) {
+    ruleError(location, `不支持的匹配字段: ${fields.filter(field => !allowedFields.has(field)).join("、")}`);
+  }
+  if (fields.some(field => arrayValue(match[field]).some(value => typeof value !== "string" || !value))) {
+    ruleError(location, "匹配值必须是非空字符串或非空字符串数组");
+  }
+  const operator = match.operator || "contains";
+  if (!MATCH_OPERATORS.has(operator)) {
+    ruleError(location, `operator 仅支持 ${[...MATCH_OPERATORS].join("、")}`);
+  }
+  if (match.case_sensitive !== undefined && typeof match.case_sensitive !== "boolean") {
+    ruleError(location, "case_sensitive 必须是布尔值");
+  }
+}
+
+function validateAction(action, location) {
+  if (!action || typeof action !== "object" || Array.isArray(action)) {
+    ruleError(location, "动作必须是对象");
+  }
+  if (!RULE_ACTIONS.has(action.type)) {
+    ruleError(location, `不支持的 type: ${action.type || "空"}`);
+  }
+  const imageFields = new Set(["src", "alt", "title", "caption", "nearby_text"]);
+  const removableImageFields = new Set([...imageFields, "sha256"]);
+  const textFields = new Set(["text"]);
+  if (action.type === "remove_image_caption") {
+    validateMatch(action.match || {}, `${location}.match`, imageFields);
+  } else if (action.type === "remove_image" || action.type === "replace_image") {
+    validateMatch(action.match, `${location}.match`, action.type === "remove_image" ? removableImageFields : imageFields);
+    if (![...removableImageFields].some(field => action.match[field] !== undefined)) {
+      ruleError(`${location}.match`, "删除或替换图片时至少需要一个图片匹配字段");
+    }
+    if (action.match.sha256 !== undefined) {
+      if (action.type !== "remove_image") {
+        ruleError(`${location}.match`, "sha256 仅支持 remove_image");
+      }
+      if (Object.keys(action.match).some(field => !["sha256", "operator", "case_sensitive"].includes(field))) {
+        ruleError(`${location}.match`, "sha256 不能与其他图片匹配字段同时使用");
+      }
+      if (action.match.operator !== undefined && action.match.operator !== "equals") {
+        ruleError(`${location}.match`, "sha256 的 operator 仅支持 equals");
+      }
+      if (arrayValue(action.match.sha256).some(value => !/^[a-f\d]{64}$/i.test(value))) {
+        ruleError(`${location}.match`, "sha256 必须是 64 位十六进制摘要");
+      }
+    }
+  } else {
+    validateMatch(action.match, `${location}.match`, textFields);
+    if (action.match.text === undefined) {
+      ruleError(`${location}.match`, "必须提供 text");
+    }
+    if (action.type === "remove_section_through_match") {
+      validateMatch(action.end_match, `${location}.end_match`, textFields);
+      if (action.end_match.text === undefined) {
+        ruleError(`${location}.end_match`, "必须提供 text");
+      }
+    }
+  }
+  if (action.type === "replace_text" && typeof action.replacement !== "string") {
+    ruleError(location, "replace_text 的 replacement 必须是字符串");
+  }
+  if (action.type === "replace_image") {
+    const replacement = action.replacement;
+    if (!replacement || typeof replacement !== "object" || Array.isArray(replacement)) {
+      ruleError(location, "replace_image 的 replacement 必须是对象");
+    }
+    const fields = Object.keys(replacement);
+    if (fields.length === 0 || fields.some(field => !new Set(["src", "alt", "title"]).has(field))) {
+      ruleError(location, "replace_image 的 replacement 仅支持 src、alt、title");
+    }
+    if (fields.some(field => typeof replacement[field] !== "string")) {
+      ruleError(location, "replace_image 的 replacement 字段必须是字符串");
+    }
+    if (/^(?:javascript|vbscript):/i.test(replacement.src || "")) {
+      ruleError(location, "replace_image 的 src 不允许脚本协议");
+    }
+  }
+}
+
+export function validateContentRules(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    ruleError("根节点", "必须是对象");
+  }
+  if (value.version !== RULE_VERSION) {
+    ruleError("version", `仅支持 ${RULE_VERSION}`);
+  }
+  if (!Array.isArray(value.rules)) {
+    ruleError("rules", "必须是数组");
+  }
+  const names = new Set();
+  value.rules.forEach((rule, ruleIndex) => {
+    const location = `rules[${ruleIndex}]`;
+    if (!rule || typeof rule !== "object" || Array.isArray(rule)) ruleError(location, "必须是对象");
+    if (typeof rule.name !== "string" || !rule.name.trim()) ruleError(`${location}.name`, "不能为空");
+    if (names.has(rule.name.trim())) ruleError(`${location}.name`, "规则名称不能重复");
+    names.add(rule.name.trim());
+    if (rule.enabled !== undefined && typeof rule.enabled !== "boolean") {
+      ruleError(`${location}.enabled`, "必须是布尔值");
+    }
+    for (const field of ["source", "project", "region", "platform"]) {
+      validateScopeValue(rule[field], `${location}.${field}`);
+    }
+    if (rule.phase !== undefined) {
+      validateScopeValue(rule.phase, `${location}.phase`);
+      if (arrayValue(rule.phase).some(phase => !RULE_PHASES.has(normalizeKey(phase)))) {
+        ruleError(`${location}.phase`, "仅支持 import、publish 或 *");
+      }
+    }
+    if (!Array.isArray(rule.actions) || rule.actions.length === 0) {
+      ruleError(`${location}.actions`, "至少需要一个动作");
+    }
+    rule.actions.forEach((action, actionIndex) => validateAction(action, `${location}.actions[${actionIndex}]`));
+  });
+  return value;
+}
+
+function decodeXmlText(value) {
+  return String(value || "")
+    .replace(/&/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"')
+    .replace(/&#(?:x([\da-f]+)|(\d+));/gi, (_, hex, decimal) => String.fromCodePoint(Number.parseInt(hex || decimal, hex ? 16 : 10)));
+}
+
+function readDocxEntries(buffer, entryPredicate) {
+  const minimumSize = 22;
+  const searchStart = Math.max(0, buffer.length - 0xffff - minimumSize);
+  let endOfCentralDirectory = -1;
+  for (let offset = buffer.length - minimumSize; offset >= searchStart; offset -= 1) {
+    if (buffer.readUInt32LE(offset) === 0x06054b50) {
+      endOfCentralDirectory = offset;
+      break;
+    }
+  }
+  if (endOfCentralDirectory === -1) throw new Error("DOCX 文件结构无效");
+
+  const entryCount = buffer.readUInt16LE(endOfCentralDirectory + 10);
+  let offset = buffer.readUInt32LE(endOfCentralDirectory + 16);
+  for (let index = 0; index < entryCount; index += 1) {
+    if (buffer.readUInt32LE(offset) !== 0x02014b50) throw new Error("DOCX 文件目录无效");
+    const compression = buffer.readUInt16LE(offset + 10);
+    const compressedSize = buffer.readUInt32LE(offset + 20);
+    const fileNameLength = buffer.readUInt16LE(offset + 28);
+    const extraLength = buffer.readUInt16LE(offset + 30);
+    const commentLength = buffer.readUInt16LE(offset + 32);
+    const localHeaderOffset = buffer.readUInt32LE(offset + 42);
+    const fileName = buffer.subarray(offset + 46, offset + 46 + fileNameLength).toString("utf8");
+    if (entryPredicate(fileName)) {
+      if (buffer.readUInt32LE(localHeaderOffset) !== 0x04034b50) throw new Error("DOCX 条目无效");
+      const localNameLength = buffer.readUInt16LE(localHeaderOffset + 26);
+      const localExtraLength = buffer.readUInt16LE(localHeaderOffset + 28);
+      const dataStart = localHeaderOffset + 30 + localNameLength + localExtraLength;
+      const data = buffer.subarray(dataStart, dataStart + compressedSize);
+      if (compression === 0) return [{ name: fileName, data }];
+      if (compression === 8) return [{ name: fileName, data: inflateRawSync(data) }];
+      throw new Error(`DOCX 使用了不支持的压缩方式: ${compression}`);
+    }
+    offset += 46 + fileNameLength + extraLength + commentLength;
+  }
+  return [];
+}
+
+function docxText(buffer) {
+  const entry = readDocxEntries(buffer, name => name === "word/document.xml")[0];
+  if (!entry) throw new Error("DOCX 中缺少正文内容");
+  const xml = entry.data.toString("utf8");
+  const paragraphs = xml.match(/<w:p\b[^>]*>[\s\S]*?<\/w:p>/g) || [];
+  return paragraphs
+    .map(paragraph => {
+      const text = [...paragraph.matchAll(/<w:t\b[^>]*>([\s\S]*?)<\/w:t>/g)].map(match => decodeXmlText(match[1])).join("");
+      return text.trim();
+    })
+    .filter(Boolean)
+    .join("\n");
+}
+
+function docxImageHashes(buffer) {
+  const images = [];
+  const minimumSize = 22;
+  const searchStart = Math.max(0, buffer.length - 0xffff - minimumSize);
+  let endOfCentralDirectory = -1;
+  for (let offset = buffer.length - minimumSize; offset >= searchStart; offset -= 1) {
+    if (buffer.readUInt32LE(offset) === 0x06054b50) {
+      endOfCentralDirectory = offset;
+      break;
+    }
+  }
+  if (endOfCentralDirectory === -1) throw new Error("DOCX 文件结构无效");
+  const entryCount = buffer.readUInt16LE(endOfCentralDirectory + 10);
+  let offset = buffer.readUInt32LE(endOfCentralDirectory + 16);
+  for (let index = 0; index < entryCount; index += 1) {
+    if (buffer.readUInt32LE(offset) !== 0x02014b50) throw new Error("DOCX 文件目录无效");
+    const compression = buffer.readUInt16LE(offset + 10);
+    const compressedSize = buffer.readUInt32LE(offset + 20);
+    const fileNameLength = buffer.readUInt16LE(offset + 28);
+    const extraLength = buffer.readUInt16LE(offset + 30);
+    const commentLength = buffer.readUInt16LE(offset + 32);
+    const localHeaderOffset = buffer.readUInt32LE(offset + 42);
+    const fileName = buffer.subarray(offset + 46, offset + 46 + fileNameLength).toString("utf8");
+    if (/^word\/media\//i.test(fileName)) {
+      if (buffer.readUInt32LE(localHeaderOffset) !== 0x04034b50) throw new Error("DOCX 条目无效");
+      const localNameLength = buffer.readUInt16LE(localHeaderOffset + 26);
+      const localExtraLength = buffer.readUInt16LE(localHeaderOffset + 28);
+      const dataStart = localHeaderOffset + 30 + localNameLength + localExtraLength;
+      const data = buffer.subarray(dataStart, dataStart + compressedSize);
+      const image = compression === 0 ? data : compression === 8 ? inflateRawSync(data) : null;
+      if (!image) throw new Error(`DOCX 使用了不支持的压缩方式: ${compression}`);
+      images.push(createHash("sha256").update(image).digest("hex"));
+    }
+    offset += 46 + fileNameLength + extraLength + commentLength;
+  }
+  return images;
+}
+
+function parseRuleText(text, file, imageHashes = []) {
+  const trimmed = String(text || "").replace(/^\uFEFF/, "").trim();
+  if (!trimmed) throw new Error(`内容规则文件为空: ${file}`);
+  if (trimmed.startsWith("{")) return JSON.parse(trimmed);
+
+  const rules = [];
+  const rule = { name: path.basename(file, path.extname(file)) || "导入规则", enabled: true, actions: [] };
+  const fields = { "规则名称": "name", "项目": "project", "地区": "region", "平台": "platform", "来源": "source", "阶段": "phase" };
+  const ignored = /^(?:#|\/\/|说明[：:]?|其他要求[：:]?)\s*/;
+  const unsupported = [];
+  let hasImageHashRule = false;
+  for (const rawLine of trimmed.split(/\r?\n/)) {
+    const line = rawLine.trim().replace(/^(?:[-*•]\s*|\d+[.、]\s*)/, "");
+    if (!line || ignored.test(line) || /(?:样式全部保留|样式.*保留不变|区分.*b站.*非b站|可以有两篇文章|^文章.*规则(?:修改)?$)/i.test(line)) continue;
+    if (line === "最强蜗牛") {
+      rule.project = line;
+      continue;
+    }
+    const scoped = line.match(/^([^：:]+)[：:]\s*(.+)$/);
+    if (scoped && fields[scoped[1].trim()]) {
+      rule[fields[scoped[1].trim()]] = scoped[2].trim();
+      continue;
+    }
+    const section = line.match(/^(?:删除章节|删除小节)[：:]\s*(.+)$/);
+    if (section) {
+      rule.actions.push({ type: "remove_section_until_next_heading", match: { text: section[1].trim(), operator: "contains" } });
+      continue;
+    }
+    const removeRange = line.match(/^(?:(?:涉及|删除段落|删除文本|删除文案)\s*[：:]?\s*)?《\s*(.+?)\s*》\s*(?:后到|至)\s*《\s*(.+?)\s*》$/);
+    if (removeRange) {
+      rule.actions.push({
+        type: "remove_section_through_match",
+        match: { text: removeRange[1].trim(), operator: "contains" },
+        end_match: { text: removeRange[2].trim(), operator: "contains" }
+      });
+      continue;
+    }
+    const removeAfter = line.match(/^(?:(?:涉及|删除段落|删除文本|删除文案)\s*[：:]?\s*)?《?\s*(.+?)\s*》?\s*(?:后的?|以后)(?:的)?全部删除/);
+    if (removeAfter) {
+      rule.actions.push({ type: "remove_section_to_end", match: { text: removeAfter[1].trim(), operator: "contains" } });
+      continue;
+    }
+    const block = line.match(/^(?:删除段落|删除文本|删除文案)[：:]\s*(.+)$/);
+    if (block) {
+      rule.actions.push({ type: "remove_text_block", match: { text: block[1].trim(), operator: "contains" } });
+      continue;
+    }
+    const replacement = line.match(/^(?:替换文本|替换文案)[：:]\s*(.+?)\s*(?:=>|→|替换为)\s*(.+)$/);
+    if (replacement) {
+      rule.actions.push({ type: "replace_text", match: { text: replacement[1].trim(), operator: "contains" }, replacement: replacement[2].trim() });
+      continue;
+    }
+    const imageSection = /^(?:b站的内容要删除如下图片|删除图片)\s*[：:]?\s*$/i.test(line);
+    if (imageSection) {
+      if (imageHashes.length > 0 && !hasImageHashRule) {
+        rules.push({
+          name: `${rule.name}-B站图片`,
+          enabled: true,
+          platform: "bilibili",
+          phase: "import",
+          actions: imageHashes.map(sha256 => ({ type: "remove_image", match: { sha256 } }))
+        });
+        hasImageHashRule = true;
+      }
+      continue;
+    }
+    const image = line.match(/^删除图片[：:]\s*(.+)$/);
+    if (image) {
+      rule.actions.push({ type: "remove_image", match: { nearby_text: image[1].trim(), operator: "contains" } });
+      continue;
+    }
+    unsupported.push(rawLine.trim());
+  }
+  if (unsupported.length > 0) {
+    throw new Error(`无法识别内容规则: ${unsupported.join("；")}。请使用“删除章节：关键词”“删除段落：关键词”“替换文本：旧文本 => 新文本”或 JSON。`);
+  }
+  if (rule.actions.length === 0 && rules.length === 0) {
+    throw new Error(`内容规则文件没有可执行规则: ${file}`);
+  }
+  if (rule.actions.length > 0) rules.push(rule);
+  return { version: RULE_VERSION, rules };
+}
+
+export async function loadContentRules(file = DEFAULT_CONTENT_RULES_FILE, options = {}) {
+  const resolved = path.resolve(file);
+  try {
+    const extension = path.extname(resolved).toLowerCase();
+    if (!new Set([".json", ".txt", ".text", ".docx"]).has(extension)) {
+      throw new Error(`内容规则文件仅支持 .json、.txt、.text 或 .docx: ${resolved}`);
+    }
+    const raw = await fs.promises.readFile(resolved);
+    const value = extension === ".docx"
+      ? parseRuleText(docxText(raw), resolved, docxImageHashes(raw))
+      : parseRuleText(raw.toString("utf8"), resolved);
+    return { ...validateContentRules(value), file: resolved };
+  } catch (error) {
+    if (error?.code === "ENOENT" && options.optional) {
+      return { file: resolved, version: RULE_VERSION, rules: [] };
+    }
+    if (error instanceof SyntaxError && path.extname(resolved).toLowerCase() === ".json") {
+      throw new Error(`内容规则文件不是有效 JSON: ${resolved} (${error.message})`);
+    }
+    throw error;
+  }
+}
+
+function contextSource(article) {
+  const source = normalizeText(article.meta?.source_url || article.payload?.source_url);
+  try {
+    const hostname = new URL(source).hostname.toLowerCase();
+    if (hostname === "mp.weixin.qq.com") return "wechat";
+    if (/feishu\.cn$|larksuite\.com$|doubao\.com$/.test(hostname)) return "lark";
+  } catch {
+    // Non-URL sources are treated as generic article content.
+  }
+  return "article";
+}
+
+function scopeMatches(configured, actual, normalizer = normalizeKey) {
+  if (configured === undefined) return true;
+  const expected = arrayValue(configured).map(normalizer);
+  return expected.includes("*") || expected.includes(normalizer(actual));
+}
+
+export function matchingContentRules(config, article, entry = {}, options = {}) {
+  const platform = entry.platformKey || canonicalPlatform(entry.platform);
+  const phase = options.phase || entry.phase || "publish";
+  return (config?.rules || []).filter(rule => {
+    if (rule.enabled === false) return false;
+    return (
+      scopeMatches(rule.source, contextSource(article)) &&
+      scopeMatches(rule.project, entry.project) &&
+      scopeMatches(rule.region, entry.region) &&
+      scopeMatches(rule.platform, platform, canonicalPlatform) &&
+      scopeMatches(rule.phase, phase)
+    );
+  });
+}
+
+function matchesValue(value, expected, match = {}) {
+  const caseSensitive = match.case_sensitive === true;
+  const normalizeForMatch = input => String(input ?? "").normalize("NFKC").replace(/\u00a0/g, " ");
+  const actualValue = normalizeForMatch(value);
+  const actual = caseSensitive ? actualValue : actualValue.toLowerCase();
+  const operator = match.operator || "contains";
+  return arrayValue(expected).some(candidateValue => {
+    const candidateValueNormalized = normalizeForMatch(candidateValue);
+    const candidate = caseSensitive ? candidateValueNormalized : candidateValueNormalized.toLowerCase();
+    if (operator === "equals") return actual === candidate;
+    if (operator === "starts_with") return actual.startsWith(candidate);
+    if (operator === "ends_with") return actual.endsWith(candidate);
+    return actual.includes(candidate);
+  });
+}
+
+function blockIsHeading($, node) {
+  const tag = String(node?.name || node?.tagName || "").toLowerCase();
+  if (/^h[1-6]$/.test(tag)) return true;
+  const element = $(node);
+  const styleText = [element.attr("style") || "", ...element.find("[style]").map((_, child) => $(child).attr("style") || "").get()]
+    .join(";");
+  const sizes = [...styleText.matchAll(/font-size\s*:\s*([\d.]+)px/gi)].map(match => Number(match[1]));
+  const bold = /font-weight\s*:\s*(?:bold|[6-9]00)/i.test(styleText) || element.find("strong,b").length > 0;
+  return sizes.some(size => size >= 16) && bold;
+}
+
+function leafMatchingBlocks($, match, options = {}) {
+  return $(BLOCK_SELECTOR)
+    .toArray()
+    .filter(node => !options.headingOnly || blockIsHeading($, node))
+    .filter(node => match.text === undefined || matchesValue($(node).text().trim(), match.text, match))
+    .filter(node => {
+      return !$(node)
+        .find(BLOCK_SELECTOR)
+        .toArray()
+        .some(child => {
+          if (options.headingOnly && !blockIsHeading($, child)) return false;
+          return match.text === undefined || matchesValue($(child).text().trim(), match.text, match);
+        });
+    });
+}
+
+function removeSectionUntilNextHeading($, match) {
+  const startNode = leafMatchingBlocks($, match, { headingOnly: true })[0];
+  if (!startNode) return false;
+  const intervals = new Map();
+  let position = 0;
+  const indexNode = node => {
+    const start = position++;
+    for (const child of node.children || []) indexNode(child);
+    intervals.set(node, { start, end: position });
+  };
+  for (const node of $.root().contents().toArray()) indexNode(node);
+  const startPosition = intervals.get(startNode)?.start;
+  const endNode = $(BLOCK_SELECTOR)
+    .toArray()
+    .find(node => {
+      const interval = intervals.get(node);
+      return interval?.start > startPosition && !$(node).find(BLOCK_SELECTOR).length && blockIsHeading($, node);
+    });
+  const endPosition = endNode ? intervals.get(endNode).start : position;
+  const inRange = node => {
+    const interval = intervals.get(node);
+    return interval && interval.start >= startPosition && interval.end <= endPosition;
+  };
+  const roots = [...intervals.keys()].filter(node => inRange(node) && (!node.parent || !inRange(node.parent)));
+  roots.forEach(node => $(node).remove());
+  return true;
+}
+
+function removeSectionToEnd($, match) {
+  const startNode = leafMatchingBlocks($, match, { headingOnly: true })[0] || leafMatchingBlocks($, match)[0];
+  if (!startNode) return false;
+
+  const hasMeaningfulContent = node => {
+    if (node.type === "text") return Boolean(String(node.data || "").trim());
+    return Boolean($(node).text().trim() || $(node).find("img,video,audio,table,hr").length);
+  };
+  let boundary = startNode;
+  while (boundary.parent && boundary.parent.type !== "root" && String(boundary.parent.name || "").toLowerCase() !== "body") {
+    const siblings = (boundary.parent.children || []).filter(hasMeaningfulContent);
+    if (siblings.findIndex(node => node === boundary) > 0) break;
+    boundary = boundary.parent;
+  }
+
+  const siblings = (boundary.parent?.children || []).filter(hasMeaningfulContent);
+  const startIndex = siblings.findIndex(node => node === boundary);
+  if (startIndex === -1) {
+    $(startNode).remove();
+    return true;
+  }
+  siblings.slice(startIndex).forEach(node => $(node).remove());
+  return true;
+}
+
+function removeSectionThroughMatch($, match, endMatch) {
+  const blocks = $(BLOCK_SELECTOR).toArray().filter(node => !$(node).find(BLOCK_SELECTOR).length);
+  const startIndex = blocks.findIndex(node => matchesValue($(node).text().trim(), match.text, match));
+  if (startIndex === -1) return false;
+  const endIndex = blocks.findIndex((node, index) => index >= startIndex && matchesValue($(node).text().trim(), endMatch.text, endMatch));
+  if (endIndex === -1) return false;
+
+  const intervals = new Map();
+  let position = 0;
+  const indexNode = node => {
+    const start = position++;
+    for (const child of node.children || []) indexNode(child);
+    intervals.set(node, { start, end: position });
+  };
+  for (const node of $.root().contents().toArray()) indexNode(node);
+  const startPosition = intervals.get(blocks[startIndex])?.start;
+  const endPosition = intervals.get(blocks[endIndex])?.end;
+  if (startPosition === undefined || endPosition === undefined) return false;
+  const inRange = node => {
+    const interval = intervals.get(node);
+    return interval && interval.start >= startPosition && interval.end <= endPosition;
+  };
+  const roots = [...intervals.keys()].filter(node => inRange(node) && (!node.parent || !inRange(node.parent)));
+  roots.forEach(node => $(node).remove());
+  return roots.length > 0;
+}
+
+function imageCaption($, image) {
+  const figureCaption = image.closest("figure").find("figcaption").first().text();
+  return figureCaption || image.next("figcaption").first().text();
+}
+
+function imageNearbyText($, image) {
+  const blockSelector = "p,li,blockquote,figure,figcaption,h1,h2,h3,h4,h5,h6,div,section,aside,footer";
+  const block = image.closest(blockSelector).first();
+  if (!block.length) return "";
+  const nearby = [block, block.prev(blockSelector).first(), block.next(blockSelector).first()];
+  return nearby
+    .filter(element => element?.length)
+    .map(element => element.text().trim())
+    .filter(Boolean)
+    .join(" ");
+}
+
+function imageMatches($, image, match) {
+  const values = {
+    src: image.attr("data-src") || image.attr("data-original") || image.attr("src") || "",
+    alt: image.attr("alt") || "",
+    title: image.attr("title") || "",
+    caption: imageCaption($, image),
+    nearby_text: imageNearbyText($, image)
+  };
+  if (match.sha256 !== undefined) return false;
+  const fields = ["src", "alt", "title", "caption", "nearby_text"].filter(field => match[field] !== undefined);
+  return fields.length === 0 || fields.every(field => matchesValue(values[field], match[field], match));
+}
+
+function removeImage($, image) {
+  const container = image.closest("p,figure,div,section").first();
+  image.closest("figure").find("figcaption").remove();
+  image.next("figcaption").remove();
+  if (
+    container.length &&
+    !container.text().trim() &&
+    container.find("img").length === 1 &&
+    container.find("video,audio,iframe,table").length === 0
+  ) {
+    container.remove();
+  } else {
+    image.remove();
+  }
+}
+
+function replaceTextNodes($, match, replacement) {
+  let changed = false;
+  const visit = node => {
+    if (node.type === "text" && matchesValue(node.data, match.text, match)) {
+      const values = arrayValue(match.text);
+      let value = String(node.data || "");
+      for (const candidate of values) {
+        const operator = match.operator || "contains";
+        if (operator === "equals") {
+          value = replacement;
+          break;
+        }
+        const flags = match.case_sensitive === true ? "g" : "gi";
+        const escaped = candidate.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        const pattern = operator === "starts_with" ? `^${escaped}` : operator === "ends_with" ? `${escaped}$` : escaped;
+        value = value.replace(new RegExp(pattern, flags), replacement);
+      }
+      node.data = value;
+      changed = true;
+      return;
+    }
+    for (const child of node.children || []) visit(child);
+  };
+  for (const node of $.root().contents().toArray()) visit(node);
+  return changed;
+}
+
+function applyAction($, action) {
+  if (action.type === "remove_section_until_next_heading") {
+    let changed = false;
+    while (removeSectionUntilNextHeading($, action.match)) changed = true;
+    return changed;
+  }
+  if (action.type === "remove_section_to_end") {
+    return removeSectionToEnd($, action.match);
+  }
+  if (action.type === "remove_section_through_match") {
+    return removeSectionThroughMatch($, action.match, action.end_match);
+  }
+  if (action.type === "remove_text_block") {
+    const blocks = leafMatchingBlocks($, action.match);
+    blocks.forEach(node => $(node).remove());
+    return blocks.length > 0;
+  }
+  if (action.type === "replace_text") {
+    return replaceTextNodes($, action.match, action.replacement);
+  }
+  const images = $("img").toArray().filter(node => imageMatches($, $(node), action.match || {}));
+  if (action.type === "remove_image") {
+    images.forEach(node => removeImage($, $(node)));
+    return images.length > 0;
+  }
+  if (action.type === "replace_image") {
+    images.forEach(node => {
+      const image = $(node);
+      for (const field of ["src", "alt", "title"]) {
+        if (action.replacement[field] === undefined) continue;
+        image.attr(field, action.replacement[field]);
+        if (field === "src") {
+          if (image.attr("data-src") !== undefined) image.attr("data-src", action.replacement.src);
+          if (image.attr("data-original") !== undefined) image.attr("data-original", action.replacement.src);
+        }
+      }
+    });
+    return images.length > 0;
+  }
+  if (action.type === "remove_image_caption") {
+    images.forEach(node => {
+      const image = $(node);
+      image.removeAttr("alt").removeAttr("title").removeAttr("aria-label");
+      image.closest("figure").find("figcaption").remove();
+      image.next("figcaption").remove();
+    });
+    return images.length > 0;
+  }
+  return false;
+}
+
+export function applyContentRules(article, entry = {}, config = entry.contentRules, options = {}) {
+  const rules = matchingContentRules(config, article, entry, options);
+  if (rules.length === 0) return article;
+  const $ = cheerio.load(String(article.html || ""), null, false);
+  const appliedRules = [];
+  const importActions = new Set([
+    "remove_section_until_next_heading",
+    "remove_section_to_end",
+    "remove_section_through_match",
+    "remove_text_block",
+    "replace_text",
+    "remove_image",
+    "replace_image",
+    "remove_image_caption"
+  ]);
+  const queuedActions = rules.flatMap((rule, ruleIndex) =>
+    rule.actions
+      .filter(action => options.phase !== "import" || importActions.has(action.type))
+      .map((action, actionIndex) => ({ rule, ruleIndex, action, actionIndex }))
+  );
+  if (options.phase === "import") {
+    const priority = {
+      remove_image: 0,
+      replace_image: 0,
+      remove_image_caption: 0,
+      remove_section_until_next_heading: 1,
+      remove_section_to_end: 1,
+      remove_section_through_match: 1,
+      remove_text_block: 2,
+      replace_text: 3
+    };
+    queuedActions.sort(
+      (left, right) =>
+        priority[left.action.type] - priority[right.action.type] ||
+        left.ruleIndex - right.ruleIndex ||
+        left.actionIndex - right.actionIndex
+    );
+  }
+  const changedRules = new Set();
+  for (const { rule, action } of queuedActions) {
+    if (action.match?.sha256 !== undefined) continue;
+    if (applyAction($, action)) changedRules.add(rule.name);
+  }
+  rules.forEach(rule => {
+    if (changedRules.has(rule.name)) appliedRules.push(rule.name);
+  });
+  return appliedRules.length === 0
+    ? article
+    : { ...article, html: $.root().html(), appliedContentRules: appliedRules };
+}
+
+export function matchingDownloadedImageRules(image, article, entry = {}, config = entry.contentRules, options = {}) {
+  if (!Buffer.isBuffer(image?.buffer)) return [];
+  const digest = createHash("sha256").update(image.buffer).digest("hex");
+  return matchingContentRules(config, article, entry, { ...options, phase: options.phase || "import" }).filter(rule =>
+    rule.actions.some(action => {
+      if (action.type !== "remove_image" || action.match?.sha256 === undefined) return false;
+      return matchesValue(digest, action.match.sha256, { ...action.match, operator: "equals" });
+    })
+  );
+}