@xingwangzhe/stalux 1.35.2 → 1.35.3

package/README.md

@@ -116,6 +116,10 @@ The subset CSS uses an exact per-character `unicode-range` and `font-display: sw
 
 The persistent BLAKE3 cache key includes font bytes, face index, normalized character set, and algorithm version. Cache files live under `node_modules/.astro/` and are reused across pages and incremental builds. Font inputs are read locally; builds do not fetch fonts from the network.
 
+Multi-page builds reuse prepared font data and hashing state through `FontSubsetter`, with up to four native worker tasks for cold subsets. Font containers are decoded/extracted to SFNT before reusable HarfBuzz preprocessing preserves original outlines; Google Brotli encodes WOFF2 at quality 8. Image dimensions, image loading hints, linked CSS text, and font character extraction share one HTML parse. Shared image dimensions and CSS-generated text are also reused within each build, and image-tag edits are assembled in a single pass.
+
+Processed pages are cached under `node_modules/.astro/stalux-page-output/`. The cache checks source HTML and page paths, referenced local CSS/image content, font inputs, and processing code. Changed inputs, missing font files, and corrupt records trigger reprocessing. Unchanged pages restore their processed output; Pagefind still rebuilds the full search index on every build. Preserve `node_modules/.astro/` to reuse caches across builds; removing it safely rebuilds them.
+
 ### Visibility-aware loading and updates
 
 The desktop tag cloud loads dynamically near the viewport. Switching to mobile, leaving the viewport or hiding the document destroys it and stops animation scheduling; becoming visible recreates it. Tag clicks use Astro client navigation. Clocks and the footer runtime update only while visible, and the date changes only on a new day. Comments load within half a viewport (capped at 400px). Tag groups, archive months and category cards retain static HTML while deferring offscreen rendering.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@xingwangzhe/stalux",
-    "version": "1.35.2",
+    "version": "1.35.3",
     "description": "A powerful, modern Astro blog theme — use as template or install as plugin",
     "keywords": [
         "astro",
@@ -106,7 +106,7 @@
         "@mcp-b/webmcp-polyfill": "^5.1.0",
         "@pagefind/component-ui": "^1.5.2",
         "@waline/client": "^3.16.0",
-        "@xingwangzhe/cjk-font-split-native": "^0.2.0",
+        "@xingwangzhe/cjk-font-split-native": "^0.4.2",
         "@xingwangzhe/satteri-mermaid": "^0.8.1",
         "@xingwangzhe/satteri-photoswipe": "^0.2.6",
         "@xingwangzhe/tags-cloud": "^1.2.9",

package/src/index.ts

@@ -19,6 +19,7 @@ import {
     readdirSync,
     readFileSync,
 } from "node:fs";
+import { createRequire } from "node:module";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import partytown from "@astrojs/partytown";
@@ -30,6 +31,7 @@ import { fontProviders } from "astro/config";
 // pagefind 是 ESM-only 包，需要在模块顶层导入
 // 因为 astro:build:done 钩子中 Vite module runner 已关闭，无法动态 import
 import { createIndex as pagefindCreateIndex } from "pagefind";
+import { parse } from "parse5";
 import { parse as parseYaml } from "yaml";
 import type { StaluxOptions } from "./config";
 import { expressiveCode } from "./expressive-code";
@@ -38,10 +40,12 @@ import {
     clearPageFontSubsets,
     readLinkedStylesheetText,
     resolveFontInputs,
-    writePageFontSubset,
+    writePageFontSubsetAsync,
 } from "./internal/font-slices";
-import { addLocalImageDimensions } from "./internal/image-dimensions";
+import { findHtmlImages } from "./internal/html-images";
+import { addLocalImageDimensions, type ImageDimensions } from "./internal/image-dimensions";
 import { createInjectedRoutes } from "./internal/injected-routes";
+import { createPageOutputCache } from "./internal/page-output-cache";
 import { createRuntimeCacheKey } from "./internal/runtime-cache-key";
 import {
     appendUniquePlugin,
@@ -49,11 +53,7 @@ import {
     prepareSatteriProcessor,
 } from "./internal/satteri-config";
 import { createViteAliases } from "./internal/vite-aliases";
-import {
-    applyHtmlImageLoadingPolicy,
-    featureFlagsHast,
-    featureFlagsMdast,
-} from "./plugins/feature-flags";
+import { featureFlagsHast, featureFlagsMdast } from "./plugins/feature-flags";
 import { temml } from "./plugins/satteri-temml";
 import { describeError } from "./utils/diagnostics";
 
@@ -386,53 +386,127 @@ export function stalux(options: StaluxOptions = {}): AstroIntegration[] {
                 // Astro's Markdown image transform drops arbitrary lazy-loading hints
                 // added during HAST processing. Reapply the policy to emitted HTML.
                 const htmlFiles = await fs.readdir(outDir, { recursive: true });
+                const sourceDir = fileURLToPath(new URL(".", import.meta.url));
+                const resolveModule = createRequire(import.meta.url).resolve;
+                const parserEntry = resolveModule("parse5");
+                const nativeEntry = resolveModule("@xingwangzhe/cjk-font-split-native");
+                const outputCache = await createPageOutputCache(
+                    path.resolve("node_modules/.astro/stalux-page-output"),
+                    [
+                        ...[
+                            "index.ts",
+                            "internal/font-slices.ts",
+                            "internal/image-dimensions.ts",
+                            "internal/html-images.ts",
+                            "internal/page-output-cache.ts",
+                            "internal/style-names.generated.ts",
+                            "plugins/feature-flags.ts",
+                            "../package.json",
+                        ].map((entry) => path.join(sourceDir, entry)),
+                        path.join(path.dirname(nativeEntry), "package.json"),
+                        path.resolve(path.dirname(parserEntry), "../package.json"),
+                    ],
+                    pageFontData?.fontBuffer,
+                    htmlFiles
+                        .filter((entry) => /\.(?:css|png|jpe?g|gif|webp)$/iu.test(entry))
+                        .map((entry) => path.join(outDir, entry)),
+                );
+                let cacheHits = 0;
                 let optimizedImagePages = 0;
                 let pageFontPages = 0;
                 if (pageFontData) await fs.mkdir(pageFontData.outputDir, { recursive: true });
                 if (pageFontData) await fs.mkdir(pageFontData.cacheDir, { recursive: true });
                 const referencedPageFonts = new Set<string>();
                 const linkedCssTextCache = new Map<string, string>();
-                for (const entry of htmlFiles) {
-                    if (typeof entry !== "string" || !entry.endsWith(".html")) continue;
+                const dimensionsCache = new Map<string, Promise<ImageDimensions | undefined>>();
+                const pageEntries = htmlFiles.filter((entry) => entry.endsWith(".html"));
+                const processPage = async (entry: string) => {
                     const output = path.join(outDir, entry);
                     const before = await fs.readFile(output, "utf8");
                     const withoutPageFont = before.replace(
                         /<style data-stalux-page-font>[\s\S]*?<\/style>/gi,
                         "",
                     );
-                    const withImageDimensions = await addLocalImageDimensions(
-                        withoutPageFont,
-                        outDir,
-                    );
-                    let after = applyHtmlImageLoadingPolicy(withImageDimensions);
+                    const cached = await outputCache.get(entry, withoutPageFont);
+                    if (cached) {
+                        if (cached.font && pageFontData) {
+                            if (!referencedPageFonts.has(cached.font.filename)) {
+                                copyFileSync(
+                                    cached.font.sourcePath,
+                                    path.join(pageFontData.outputDir, cached.font.filename),
+                                );
+                            }
+                            referencedPageFonts.add(cached.font.filename);
+                            pageFontPages++;
+                        }
+                        if (cached.html !== before) {
+                            await fs.writeFile(output, cached.html);
+                            optimizedImagePages++;
+                        }
+                        cacheHits++;
+                        return;
+                    }
+                    let cachedFont: { filename: string; sourcePath: string } | undefined;
+                    const dependencies = new Set<string>();
+                    const document = parse(withoutPageFont, { sourceCodeLocationInfo: true });
+                    const images = findHtmlImages(withoutPageFont, document);
+                    let after = await addLocalImageDimensions(withoutPageFont, outDir, {
+                        images,
+                        cache: dimensionsCache,
+                        loadingPolicy: true,
+                        dependencies,
+                    });
                     if (pageFontData) {
                         const linkedStylesheetText = readLinkedStylesheetText(
                             after,
                             output,
                             outDir,
                             linkedCssTextCache,
+                            document,
+                            dependencies,
                         );
-                        const pageFont = writePageFontSubset(
+                        const pageFont = await writePageFontSubsetAsync(
                             after,
                             pageFontData.fontBuffer,
                             pageFontData.cacheDir,
                             "/_astro/fonts/",
                             linkedStylesheetText,
+                            "",
+                            document,
                         );
                         if (pageFont) {
                             after = pageFont.html;
                             pageFontPages++;
+                            cachedFont = {
+                                filename: pageFont.filename,
+                                sourcePath: pageFont.sourcePath,
+                            };
+                            if (!referencedPageFonts.has(pageFont.filename)) {
+                                copyFileSync(
+                                    pageFont.sourcePath,
+                                    path.join(pageFontData.outputDir, pageFont.filename),
+                                );
+                            }
                             referencedPageFonts.add(pageFont.filename);
-                            copyFileSync(
-                                pageFont.sourcePath,
-                                path.join(pageFontData.outputDir, pageFont.filename),
-                            );
                         }
                     }
                     if (after !== before) {
                         await fs.writeFile(output, after);
                         optimizedImagePages++;
                     }
+                    await outputCache.set(
+                        entry,
+                        withoutPageFont,
+                        {
+                            html: after,
+                            font: cachedFont,
+                        },
+                        [...dependencies],
+                    );
+                };
+                // Bound I/O concurrency without retaining the entire site's HTML in memory.
+                for (let offset = 0; offset < pageEntries.length; offset += 4) {
+                    await Promise.all(pageEntries.slice(offset, offset + 4).map(processPage));
                 }
                 if (pageFontData) {
                     clearPageFontSubsets(pageFontData.outputDir, referencedPageFonts);
@@ -441,11 +515,15 @@ export function stalux(options: StaluxOptions = {}): AstroIntegration[] {
                 logger.info(
                     `generated page-specific body font subsets for ${pageFontPages} HTML pages`,
                 );
+                logger.info(
+                    `HTML postprocessing ${(performance.now() - started).toFixed(1)}ms; cache ${cacheHits}/${htmlFiles.filter((entry) => entry.endsWith(".html")).length}`,
+                );
 
                 // 后处理：Pagefind 搜索索引。启用时任何失败都必须让构建失败，
                 // 避免发布一个页面正常但搜索已损坏的产物。
                 if (opt.pagefind) {
                     logger.info("Running Pagefind indexer...");
+                    const pagefindStarted = performance.now();
 
                     try {
                         const { index, errors } = await pagefindCreateIndex();
@@ -466,7 +544,7 @@ export function stalux(options: StaluxOptions = {}): AstroIntegration[] {
                         });
 
                         logger.info(
-                            `indexed ${page_count} pages → ${outputPath} (${(performance.now() - started).toFixed(1)}ms)`,
+                            `indexed ${page_count} pages → ${outputPath} (${(performance.now() - pagefindStarted).toFixed(1)}ms)`,
                         );
                     } catch (error) {
                         logger.error(`Pagefind indexing failed: ${describeError(error)}`);

package/src/internal/font-slices.ts

@@ -18,7 +18,7 @@ import { styleNames } from "./style-names.generated.ts";
 import { existsSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
 import { dirname, join, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { subsetFont } from "@xingwangzhe/cjk-font-split-native";
+import { FontSubsetter } from "@xingwangzhe/cjk-font-split-native";
 import type { AstroIntegrationLogger } from "astro";
 import { type DefaultTreeAdapterMap, parse } from "parse5";
 
@@ -46,6 +46,8 @@ const PAGE_SLICE_OUT_DIR = "node_modules/.astro/stalux-page-fonts";
  */
 export const RESERVED_GLYPHS = "0123456789";
 
+const preparedFonts = new WeakMap<Buffer, FontSubsetter>();
+
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -164,10 +166,12 @@ export function readLinkedStylesheetText(
     pagePath: string,
     outputDir: string,
     cache = new Map<string, string>(),
+    document = parse(html),
+    dependencies?: Set<string>,
 ): string {
     const root = resolve(outputDir);
     const links: string[] = [];
-    collectStylesheetLinks(parse(html), links);
+    collectStylesheetLinks(document, links);
     const content: string[] = [];
     for (const href of links) {
         if (/^(?:[a-z][a-z\d+.-]*:|\/\/|data:)/iu.test(href)) continue;
@@ -180,14 +184,15 @@ export function readLinkedStylesheetText(
             continue;
         }
         if (cssPath !== root && !cssPath.startsWith(`${root}${sep}`)) continue;
+        dependencies?.add(cssPath);
         if (!cache.has(cssPath)) {
             try {
-                cache.set(cssPath, readFileSync(cssPath, "utf8"));
+                cache.set(cssPath, cssGeneratedText(readFileSync(cssPath, "utf8")));
             } catch {
                 cache.set(cssPath, "");
             }
         }
-        content.push(cssGeneratedText(cache.get(cssPath) ?? ""));
+        content.push(cache.get(cssPath) ?? "");
     }
     return content.join(" ");
 }
@@ -256,8 +261,40 @@ export function writePageFontSubset(
     publicUrlPrefix = "/_astro/fonts/",
     linkedStylesheetText = "",
     extraChars = "",
+    document = parse(html),
 ): PageFontSubset | undefined {
-    const document = parse(html);
+    const input = preparePageFont(html, fontBuffer, linkedStylesheetText, extraChars, document);
+    if (!input) return undefined;
+    return renderPageFont(
+        html,
+        publicUrlPrefix,
+        input.chars,
+        input.prepared.subset(input.chars.join(""), cacheDir),
+    );
+}
+
+export async function writePageFontSubsetAsync(
+    html: string,
+    fontBuffer: Buffer,
+    cacheDir: string,
+    publicUrlPrefix = "/_astro/fonts/",
+    linkedStylesheetText = "",
+    extraChars = "",
+    document = parse(html),
+): Promise<PageFontSubset | undefined> {
+    const input = preparePageFont(html, fontBuffer, linkedStylesheetText, extraChars, document);
+    if (!input) return undefined;
+    const result = await input.prepared.subsetAsync(input.chars.join(""), cacheDir);
+    return renderPageFont(html, publicUrlPrefix, input.chars, result);
+}
+
+function preparePageFont(
+    html: string,
+    fontBuffer: Buffer,
+    linkedStylesheetText: string,
+    extraChars: string,
+    document: DefaultTreeAdapterMap["document"],
+) {
     const body = findBody(document);
     if (!body) return undefined;
 
@@ -274,7 +311,20 @@ export function writePageFontSubset(
     );
     if (chars.length === 0) return undefined;
 
-    const result = subsetFont(fontBuffer, chars.join(""), cacheDir);
+    let prepared = preparedFonts.get(fontBuffer);
+    if (!prepared) {
+        prepared = new FontSubsetter(fontBuffer);
+        preparedFonts.set(fontBuffer, prepared);
+    }
+    return { chars, prepared };
+}
+
+function renderPageFont(
+    html: string,
+    publicUrlPrefix: string,
+    chars: string[],
+    result: { hash: string; path: string; cacheHit: boolean },
+): PageFontSubset {
     const filename = `page-${result.hash}.woff2`;
 
     const rel = `${publicUrlPrefix}${filename}`;

package/src/internal/html-images.ts

@@ -10,7 +10,10 @@ export interface HtmlImage {
 }
 
 /** Source ranges preserve scripts and code-copy attributes byte-for-byte. */
-export function findHtmlImages(html: string): HtmlImage[] {
+export function findHtmlImages(
+    html: string,
+    document = parse(html, { sourceCodeLocationInfo: true }),
+): HtmlImage[] {
     const images: HtmlImage[] = [];
     function visit(node: DefaultTreeAdapterMap["node"], body?: number) {
         if ("tagName" in node) {
@@ -35,10 +38,28 @@ export function findHtmlImages(html: string): HtmlImage[] {
         }
         if ("childNodes" in node) for (const child of node.childNodes) visit(child, body);
     }
-    visit(parse(html, { sourceCodeLocationInfo: true }));
+    visit(document);
     return images.sort((left, right) => left.start - right.start);
 }
 
+export function imageLoadingUpdates(images: HtmlImage[]): Map<HtmlImage, Record<string, string>> {
+    const firstSeen = new Set<number>();
+    const changes = new Map<HtmlImage, Record<string, string>>();
+    for (const image of images) {
+        if (image.body === undefined) continue;
+        const first = !firstSeen.has(image.body);
+        firstSeen.add(image.body);
+        const updates: Record<string, string> = {
+            decoding: image.attributes.get("decoding") || "async",
+            loading: first ? "eager" : "lazy",
+        };
+        if (first) updates.fetchpriority = "high";
+        else if (image.attributes.get("fetchpriority") === "high") updates.fetchpriority = "auto";
+        changes.set(image, updates);
+    }
+    return changes;
+}
+
 export function updateImageTag(image: HtmlImage, updates: Record<string, string>): string {
     let tag = image.tag;
     const edits: Array<{ start: number; end: number; value: string }> = [];

package/src/internal/image-dimensions.ts

@@ -1,6 +1,6 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { findHtmlImages, updateImageTag } from "./html-images";
+import { findHtmlImages, type HtmlImage, imageLoadingUpdates, updateImageTag } from "./html-images";
 
 export type ImageDimensions = { width: number; height: number };
 
@@ -72,41 +72,68 @@ export function readImageDimensions(data: Buffer): ImageDimensions | undefined {
 }
 
 /** Add width/height to same-origin emitted images so their space is reserved before download. */
-export async function addLocalImageDimensions(html: string, outputDir: string): Promise<string> {
-    const dimensionsCache = new Map<string, Promise<ImageDimensions | undefined>>();
+export async function addLocalImageDimensions(
+    html: string,
+    outputDir: string,
+    options: {
+        images?: HtmlImage[];
+        cache?: Map<string, Promise<ImageDimensions | undefined>>;
+        loadingPolicy?: boolean;
+        dependencies?: Set<string>;
+    } = {},
+): Promise<string> {
+    const dimensionsCache =
+        options.cache ?? new Map<string, Promise<ImageDimensions | undefined>>();
     const root = path.resolve(outputDir);
-    const tags = findHtmlImages(html);
-
-    for (const image of tags.reverse()) {
-        if (image.attributes.has("width") && image.attributes.has("height")) continue;
+    const images = options.images ?? findHtmlImages(html);
+    const loading = options.loadingPolicy ? imageLoadingUpdates(images) : new Map();
+    const replacements: Array<{ start: number; end: number; tag: string }> = [];
+    for (const image of images) {
+        const updates: Record<string, string> = { ...loading.get(image) };
         const src = image.attributes.get("src");
-        if (!src) continue;
-
-        let filePath: string;
-        try {
-            const url = new URL(src, "https://stalux.invalid");
-            if (url.origin !== "https://stalux.invalid") continue;
-            filePath = path.resolve(root, `.${decodeURIComponent(url.pathname)}`);
-        } catch {
-            continue;
+        if (src && !(image.attributes.has("width") && image.attributes.has("height"))) {
+            let filePath: string | undefined;
+            try {
+                const url = new URL(src, "https://stalux.invalid");
+                if (url.origin === "https://stalux.invalid") {
+                    const candidate = path.resolve(root, `.${decodeURIComponent(url.pathname)}`);
+                    if (candidate === root || candidate.startsWith(`${root}${path.sep}`))
+                        filePath = candidate;
+                }
+            } catch {
+                // Invalid image URLs still receive the loading policy.
+            }
+            if (filePath) {
+                options.dependencies?.add(filePath);
+                let dimensions = dimensionsCache.get(filePath);
+                if (!dimensions) {
+                    dimensions = readFile(filePath)
+                        .then(readImageDimensions)
+                        .catch(() => undefined);
+                    dimensionsCache.set(filePath, dimensions);
+                }
+                const size = await dimensions;
+                if (size && size.width > 0 && size.height > 0) {
+                    if (!image.attributes.has("width")) updates.width = String(size.width);
+                    if (!image.attributes.has("height")) updates.height = String(size.height);
+                }
+            }
         }
-        if (filePath !== root && !filePath.startsWith(`${root}${path.sep}`)) continue;
-
-        let dimensions = dimensionsCache.get(filePath);
-        if (!dimensions) {
-            dimensions = readFile(filePath)
-                .then(readImageDimensions)
-                .catch(() => undefined);
-            dimensionsCache.set(filePath, dimensions);
+        if (Object.keys(updates).length) {
+            replacements.push({
+                start: image.start,
+                end: image.end,
+                tag: updateImageTag(image, updates),
+            });
         }
-        const size = await dimensions;
-        if (!size || size.width <= 0 || size.height <= 0) continue;
-
-        const updates: Record<string, string> = {};
-        if (!image.attributes.has("width")) updates.width = String(size.width);
-        if (!image.attributes.has("height")) updates.height = String(size.height);
-        const updated = updateImageTag(image, updates);
-        html = html.slice(0, image.start) + updated + html.slice(image.end);
     }
-    return html;
+    if (!replacements.length) return html;
+    const parts: string[] = [];
+    let offset = 0;
+    for (const replacement of replacements) {
+        parts.push(html.slice(offset, replacement.start), replacement.tag);
+        offset = replacement.end;
+    }
+    parts.push(html.slice(offset));
+    return parts.join("");
 }

package/src/internal/page-output-cache.ts

@@ -0,0 +1,78 @@
+import { createHash } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+
+export interface CachedPageOutput {
+    html: string;
+    font?: { filename: string; sourcePath: string };
+}
+
+const digest = (value: string | Buffer) => createHash("sha256").update(value).digest("hex");
+
+/** Content hashes include dependencies even when their public URL has not changed. */
+export async function createPageOutputCache(
+    directory: string,
+    dependencies: readonly string[],
+    font?: Buffer,
+    assets: readonly string[] = [],
+) {
+    const hash = createHash("sha256").update("stalux-page-output-v1\0");
+    if (font) hash.update(font);
+    for (const dependency of [...dependencies].sort()) {
+        hash.update(dependency).update("\0");
+        hash.update(await fs.readFile(dependency)).update("\0");
+    }
+    const namespace = path.join(directory, hash.digest("hex"));
+    await fs.mkdir(namespace, { recursive: true });
+    const assetDigests = new Map<string, string>();
+    for (const asset of assets) assetDigests.set(asset, digest(await fs.readFile(asset)));
+    const key = (entry: string, html: string) => digest(`${entry}\0${html}`);
+    return {
+        async get(entry: string, html: string): Promise<CachedPageOutput | undefined> {
+            try {
+                const record = JSON.parse(
+                    await fs.readFile(path.join(namespace, `${key(entry, html)}.json`), "utf8"),
+                );
+                if (typeof record.html !== "string" || digest(record.html) !== record.digest)
+                    return undefined;
+                if (!Array.isArray(record.assets)) return undefined;
+                for (const [asset, expected] of record.assets) {
+                    if ((assetDigests.get(asset) ?? null) !== expected) return undefined;
+                }
+                if (record.font) {
+                    if (
+                        !/^page-[a-f\d]+\.woff2$/u.test(record.font.filename) ||
+                        typeof record.font.sourcePath !== "string" ||
+                        !(await fs.stat(record.font.sourcePath)).isFile()
+                    )
+                        return undefined;
+                }
+                return { html: record.html, font: record.font };
+            } catch {
+                // Missing, truncated, or invalid cache entries are rebuilt from source.
+                return undefined;
+            }
+        },
+        async set(
+            entry: string,
+            html: string,
+            output: CachedPageOutput,
+            referencedAssets: readonly string[] = [],
+        ): Promise<void> {
+            const target = path.join(namespace, `${key(entry, html)}.json`);
+            const temporary = `${target}.${process.pid}.tmp`;
+            await fs.writeFile(
+                temporary,
+                JSON.stringify({
+                    ...output,
+                    digest: digest(output.html),
+                    assets: referencedAssets.map((asset) => [
+                        asset,
+                        assetDigests.get(asset) ?? null,
+                    ]),
+                }),
+            );
+            await fs.rename(temporary, target);
+        },
+    };
+}

package/src/plugins/feature-flags.ts

@@ -16,7 +16,7 @@ import type { HastVisitorContext, MdastNode, MdastVisitorContext } from "satteri
  * - 数学公式由 satteri-temml 插件直接输出 MathML，无需额外标记
  */
 import { defineHastPlugin, defineMdastPlugin } from "satteri";
-import { findHtmlImages, updateImageTag } from "../internal/html-images";
+import { findHtmlImages, imageLoadingUpdates, updateImageTag } from "../internal/html-images";
 import { logDetail } from "../utils/diagnostics";
 
 declare module "satteri" {
@@ -247,22 +247,10 @@ export function applyImageLoadingPolicy(
 }
 
 export function applyHtmlImageLoadingPolicy(html: string): string {
-    const firstSeen = new Set<number>();
-    const changes = findHtmlImages(html)
-        .filter((image) => image.body !== undefined)
-        .map((image) => {
-            const body = image.body as number;
-            const first = !firstSeen.has(body);
-            firstSeen.add(body);
-            const updates: Record<string, string> = {
-                decoding: image.attributes.get("decoding") || "async",
-                loading: first ? "eager" : "lazy",
-            };
-            if (first) updates.fetchpriority = "high";
-            else if (image.attributes.get("fetchpriority") === "high")
-                updates.fetchpriority = "auto";
-            return { image, tag: updateImageTag(image, updates) };
-        });
+    const changes = [...imageLoadingUpdates(findHtmlImages(html))].map(([image, updates]) => ({
+        image,
+        tag: updateImageTag(image, updates),
+    }));
     for (const { image, tag } of changes.reverse())
         html = html.slice(0, image.start) + tag + html.slice(image.end);
     return html;