@xingwangzhe/stalux 1.35.2 → 1.35.5

package/public/fonts/LXGW-WenKai-OFL.txt

@@ -0,0 +1,94 @@
+Copyright 2021-2026 LXGW (https://github.com/lxgw/LxgwWenKai), with Reserved Font Name '霞鹜', '霞鶩', '落霞孤鹜', '落霞孤鶩' and 'LXGW'. [ADDITIONAL PERMISSION] The Reserved Font Names '霞鹜', '霞鶩', '落霞孤鹜', '落霞孤鶩' and 'LXGW' may continue to be used in Modified Versions recompiled from the Original Version, without modifications to the font source code; or in Modified Versions subsetted or converted to other formats (e.g., WOFF/WOFF2) solely for web font delivery, provided such Modified Versions are not made available as installable desktop fonts (e.g., on mainstream platforms like Google Fonts, or third-party non-commercial platforms recognized by the author @lxgw; other web font platforms please contact the author @lxgw for confirmation).
+Copyright 2020 The Klee Project Authors (https://github.com/fontworks-fonts/Klee)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://openfontlicense.org
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

package/public/fonts/StaluxMathAux-OFL.txt

@@ -0,0 +1,93 @@
+Copyright (c) 2009-2010 Design Science, Inc.
+Copyright (c) 2014-2018 Khan Academy
+Original fonts have Reserved Font Names KaTeX_Main and KaTeX_Script.
+Modified font: Stalux Math Aux. Copyright (c) 2026 xingwangzhe.
+Renamed, script codepoints remapped, primes scaled/repeated/reflected;
+rebuilt with FontTools without FontCreator or its generated binaries.
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

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";
 
@@ -123,6 +123,21 @@ function syncBackgroundSvgs(srcDir: string): { copied: number; skipped: number }
     return { copied, skipped };
 }
 
+/** Sync packaged math fonts and licensing notices; Astro does not merge integration public directories. */
+function syncFontAssets(srcDir: string): void {
+    const source = path.join(srcDir, "../public/fonts");
+    if (!existsSync(source)) return;
+    const destination = path.resolve(process.cwd(), "public/fonts");
+    mkdirSync(destination, { recursive: true });
+    for (const name of readdirSync(source)) {
+        if (!/\.(?:woff2|txt)$/u.test(name)) continue;
+        const from = path.join(source, name);
+        const to = path.join(destination, name);
+        if (existsSync(to) && readFileSync(from).equals(readFileSync(to))) continue;
+        copyFileSync(from, to);
+    }
+}
+
 // ---------------------------------------------------------------------------
 // 集成入口
 // ---------------------------------------------------------------------------
@@ -230,6 +245,7 @@ export function stalux(options: StaluxOptions = {}): AstroIntegration[] {
                 // 破坏增量构建依赖图 hash）。Astro 不会合并集成的 public 目录，这里显式同步一次。
                 // 判别式：内容一致跳过（幂等），内容不同才覆盖，用户新增文件保留。
                 try {
+                    syncFontAssets(srcDir);
                     const { copied, skipped } = syncBackgroundSvgs(srcDir);
                     if (copied > 0) {
                         assetsLogger.info(`同步背景 SVG ${copied} 个（跳过 ${skipped} 个不变）`);
@@ -386,53 +402,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 +531,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 +560,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 }> = [];