@file-viewer/renderer-pdf 2.1.24 → 2.1.26

package/README.en.md

@@ -25,21 +25,28 @@ const options = {
 
 ## Offline Assets
 
-PDF preview depends on the PDF.js worker, cMaps, WASM helpers, and standard fonts. Asset paths use the same unified options as `@file-viewer/core`:
+PDF preview depends on the PDF.js worker, cMaps, WASM helpers, standard fonts, and an offline fallback for unembedded CJK fonts. Asset paths use the same unified options as `@file-viewer/core`:
 
 ```ts
 const options = {
   renderers: pdfRenderer,
   pdf: {
+    assetBaseUrl: '/workspace/',
     workerUrl: '/vendor/pdf/pdf.worker.mjs',
     cMapUrl: '/vendor/pdf/cmaps/',
     wasmUrl: '/vendor/pdf/wasm/',
     standardFontDataUrl: '/vendor/pdf/standard_fonts/',
+    cjkFontFallbackPath: '/vendor/pdf/fonts/',
+    identityFontRepair: true,
   },
 }
 ```
 
-When no explicit URL is provided, the renderer first probes `/vendor/pdf/pdf.worker.mjs` from the site root. If the host app did not run `file-viewer-copy-assets`, does not use `@file-viewer/vite-plugin`, or a local dev server falls back to HTML for that path, the renderer lazy-loads the packaged PDF.js worker handler as a compatibility fallback so preview does not fail with `Setting up fake worker failed`. For best performance, full cMap/WASM/standard-font support, or strict offline deployments, still copy viewer assets and point these URLs at real static files.
+When no explicit PDF asset URL is configured, the renderer first uses the public base exposed by build tools such as Vite and can fall back to the page entry script. An app deployed under `/workspace/` therefore still requests `/workspace/vendor/pdf/pdf.worker.mjs` while its current SPA route is `/workspace/c/`. UMI, custom proxies, and builds whose public path cannot be detected can set `pdf.assetBaseUrl: '/workspace/'` to pin the base for every PDF offline asset. If the host app did not run `file-viewer-copy-assets`, does not use `@file-viewer/vite-plugin`, or a local dev server falls back to HTML for that path, the renderer lazy-loads the packaged PDF.js worker handler as a compatibility fallback so preview does not fail with `Setting up fake worker failed`. For best performance, complete cMap/standard-font/WASM decoding, or strict offline deployments, still copy viewer assets and point these URLs at real static files. The pinned PDF.js 5.4 stable line loads local JBIG2, JPEG 2000, color-management, and related helpers through `wasmUrl`; viewer assets and the Vite plugin copy them without relying on the public internet.
+
+`cjkFontFallback` is enabled by default. When a PDF references `MicrosoftYaHei-Bold`, SimSun, SimHei, or another CJK font without embedding the font program, the renderer prefers an installed system font and otherwise aliases the original PDF font name to the bundled Noto Sans SC variable font. Only WOFF2 shards needed by the current page text are loaded. The first page waits for the font before rendering, and later pages are redrawn when they introduce new glyphs. Set the option to `false` to disable this behavior, or point `cjkFontFallbackPath` at a self-hosted directory with the same structure.
+
+`identityFontRepair` is also enabled by default for malformed PDFs that write TrueType glyph IDs through `Identity-H`/`Identity-V` but omit `ToUnicode`. The repair module is loaded only after CJK font substitution and multiple control-character glyphs are detected. If the same PDF embeds a usable same-family TrueType font, its cmap is used to rebuild the Unicode mapping for the in-memory preview. The repair is applied only to a preview copy and never overwrites the original file or download source; an unsafe or unsupported repair falls back to the original preview. Set the option to `false` to disable this compatibility path.
 
 ## Migration Note
 

package/README.md

@@ -25,21 +25,28 @@ const options = {
 
 ## 离线资源
 
-PDF 预览依赖 PDF.js worker、cMaps、WASM 和 standard fonts。资源路径沿用 `@file-viewer/core` 的统一 options：
+PDF 预览依赖 PDF.js worker、cMaps、WASM、standard fonts，以及未嵌入中文字体的离线回退资源。资源路径沿用 `@file-viewer/core` 的统一 options：
 
 ```ts
 const options = {
   renderers: pdfRenderer,
   pdf: {
+    assetBaseUrl: '/workspace/',
     workerUrl: '/vendor/pdf/pdf.worker.mjs',
     cMapUrl: '/vendor/pdf/cmaps/',
     wasmUrl: '/vendor/pdf/wasm/',
     standardFontDataUrl: '/vendor/pdf/standard_fonts/',
+    cjkFontFallbackPath: '/vendor/pdf/fonts/',
+    identityFontRepair: true,
   },
 }
 ```
 
-默认未显式配置时，渲染器会先探测站点根路径的 `/vendor/pdf/pdf.worker.mjs`。如果客户项目没有执行 `file-viewer-copy-assets`、没有使用 `@file-viewer/vite-plugin`，或者本地临时服务器把该路径回退成 HTML，PDF renderer 会自动懒加载包内 PDF.js worker handler 作为兼容兜底，避免 `Setting up fake worker failed` 直接中断预览。需要最佳性能、完整 cMap/WASM/standard fonts 或严格离线部署时，仍建议复制 viewer assets 并配置真实静态地址。
+默认未显式配置时，渲染器优先使用 Vite 等构建器提供的公开基址，并可从页面入口脚本回退识别部署子路径。因此应用部署在 `/workspace/`、当前 SPA 路由为 `/workspace/c/` 时，仍会请求 `/workspace/vendor/pdf/pdf.worker.mjs`。UMI、自定义代理或无法自动识别的构建环境可以设置 `pdf.assetBaseUrl: '/workspace/'` 固定全部 PDF 离线资源的基址。如果项目没有执行 `file-viewer-copy-assets`、没有使用 `@file-viewer/vite-plugin`，或者本地临时服务器把该路径回退成 HTML，PDF renderer 会自动懒加载包内 PDF.js worker handler 作为兼容兜底，避免 `Setting up fake worker failed` 直接中断预览。需要最佳性能、完整 cMap/standard fonts/WASM 解码或严格离线部署时，仍建议复制 viewer assets 并配置真实静态地址。当前锁定的 PDF.js 5.4 稳定线会通过 `wasmUrl` 本地加载 JBIG2、JPEG 2000、颜色管理等辅助资源；这些资源由 viewer assets 和 Vite 插件统一复制，不依赖公网。
+
+`cjkFontFallback` 默认开启。PDF 引用了 `MicrosoftYaHei-Bold`、宋体、黑体或其他中文字体但没有嵌入字体数据时，渲染器优先使用本机字体；本机缺失时，会把原 PDF 字体名映射到本地 Noto Sans SC 可变字体，并根据当前页实际文字只加载需要的 WOFF2 分片。首屏会在字体就绪后再渲染，后续页发现新字形时会自动重绘。可设为 `false` 完全关闭，或用 `cjkFontFallbackPath` 指向同结构的自托管字体目录。
+
+`identityFontRepair` 也默认开启，用于少数把 TrueType 字形 ID 写入 `Identity-H`/`Identity-V`、却遗漏 `ToUnicode` 的异常 PDF。只有检测到中文字体替换和多个控制字符乱码时，渲染器才会懒加载修复模块；若文件内同时嵌入了可用的同族 TrueType 字体，就从其 cmap 重建内存预览所需的 Unicode 映射。修复只作用于预览副本，不覆盖原始文件和下载源；无法安全修复时继续使用原预览。可设为 `false` 关闭。
 
 ## 迁移说明
 

package/dist/pdf.js

@@ -3,6 +3,7 @@ import { EventBus, GenericL10n, PDFFindController, PDFLinkService, PDFViewer, }
 import { registerFileViewerSearchProvider, registerFileViewerZoomProvider, unregisterFileViewerSearchProvider, unregisterFileViewerZoomProvider, registerFileViewerViewStateProvider, unregisterFileViewerViewStateProvider, createFileViewerZoomChangeEmitter, createFileViewerViewStateChange, createFileViewerViewStateChangeEmitter, createFileViewerTranslator, buildPrintPageStyle, formatCssPixels, DEFAULT_PDF_RANGE_CHUNK_SIZE, resolveFileViewerLocale, resolveFileViewerFitScale, } from '@file-viewer/core';
 import { DEFAULT_FILE_VIEWER_PDF_WORKER_PATH, resolveFileViewerPdfAssetUrls, } from '@file-viewer/core/assets';
 import { pdfViewerStyle } from './pdfStyles.js';
+import { collectMalformedIdentityFontNames, createPdfCjkFontFallbackManager, detectMalformedIdentityCjkFontFamilies, } from './pdfFontFallback.js';
 export const DEFAULT_FILE_VIEWER_PDF_WORKER_URL = DEFAULT_FILE_VIEWER_PDF_WORKER_PATH;
 const MIN_SCALE = 0.2;
 const MAX_SCALE = 3;
@@ -19,6 +20,7 @@ const normalizedPdfViewerStyle = pdfViewerStyle
     .replace(/--page-border-image:\s*url\(images\/shadow\.png\)\s*9 9 repeat;/g, '--page-border-image:none;')
     .replace(/background:\s*url\("\.\/images\/loading-icon\.gif"\)\s*center no-repeat;/g, 'background:none;');
 const pdfJsConsoleErrorSuppressions = new WeakMap();
+const pdfJsConsoleWarningSuppressions = new WeakMap();
 const createStyle = (documentRef) => {
     const style = documentRef.createElement('style');
     style.textContent = `${normalizedPdfViewerStyle}
@@ -164,6 +166,63 @@ const suppressPdfJsDestroyedTransportPageInitErrors = (view) => {
         }, PDF_JS_DESTROY_CONSOLE_SUPPRESSION_MS);
     };
 };
+const isPdfJsMissingSystemFontWarning = (args) => {
+    const [message] = args;
+    return typeof message === 'string' &&
+        /^(?:Warning:\s*)?Cannot load system font: .+installing it could help to improve PDF rendering\.$/.test(message);
+};
+const suppressPdfJsMissingSystemFontWarnings = (view) => {
+    const consoleRef = (view.console ||
+        globalThis.console);
+    if (!consoleRef || typeof consoleRef.warn !== 'function') {
+        return () => { };
+    }
+    let suppression = pdfJsConsoleWarningSuppressions.get(consoleRef);
+    if (!suppression) {
+        const originalWarn = consoleRef.warn;
+        suppression = {
+            originalWarn,
+            patchedWarn: (...args) => {
+                if (isPdfJsMissingSystemFontWarning(args)) {
+                    return;
+                }
+                return originalWarn.apply(consoleRef, args);
+            },
+            depth: 0,
+            restoreTimer: undefined,
+        };
+        pdfJsConsoleWarningSuppressions.set(consoleRef, suppression);
+        consoleRef.warn = suppression.patchedWarn;
+    }
+    else if (suppression.restoreTimer !== undefined) {
+        view.clearTimeout(suppression.restoreTimer);
+        suppression.restoreTimer = undefined;
+    }
+    suppression.depth += 1;
+    let released = false;
+    return () => {
+        if (released) {
+            return;
+        }
+        released = true;
+        const current = pdfJsConsoleWarningSuppressions.get(consoleRef);
+        if (!current) {
+            return;
+        }
+        current.depth = Math.max(0, current.depth - 1);
+        if (current.depth || current.restoreTimer !== undefined) {
+            return;
+        }
+        current.restoreTimer = view.setTimeout(() => {
+            current.restoreTimer = undefined;
+            if (current.depth || consoleRef.warn !== current.patchedWarn) {
+                return;
+            }
+            consoleRef.warn = current.originalWarn;
+            pdfJsConsoleWarningSuppressions.delete(consoleRef);
+        }, PDF_JS_DESTROY_CONSOLE_SUPPRESSION_MS);
+    };
+};
 const isConfiguredUrl = (value) => {
     return value !== undefined && value !== null && String(value).trim().length > 0;
 };
@@ -192,8 +251,52 @@ const installBundledPdfFakeWorker = async () => {
         WorkerMessageHandler: workerModule.WorkerMessageHandler,
     };
 };
-const resolvePdfWorkerUrl = (options, documentUrl) => {
-    return resolveFileViewerPdfAssetUrls(options, documentUrl).workerUrl;
+const resolvePdfWorkerUrl = (options, documentBaseUrl) => {
+    return resolveFileViewerPdfAssetUrls(options, documentBaseUrl).workerUrl;
+};
+const readBundlerPublicBaseUrl = () => {
+    var _a;
+    try {
+        const value = (_a = import.meta.env) === null || _a === void 0 ? void 0 : _a.BASE_URL;
+        return typeof value === 'string' ? value.trim() : '';
+    }
+    catch {
+        return '';
+    }
+};
+const resolvePdfRuntimeAssetBaseUrl = (documentRef) => {
+    const documentBaseUrl = documentRef.baseURI || documentRef.URL || 'file:///';
+    const bundlerBaseUrl = readBundlerPublicBaseUrl();
+    if (bundlerBaseUrl && bundlerBaseUrl !== '.' && bundlerBaseUrl !== './') {
+        try {
+            return new URL(bundlerBaseUrl.endsWith('/') ? bundlerBaseUrl : `${bundlerBaseUrl}/`, documentBaseUrl).href;
+        }
+        catch {
+            // Continue with DOM-based public-path detection.
+        }
+    }
+    // An explicit <base> is authoritative and already reflected by baseURI.
+    if (documentRef.querySelector('base[href]')) {
+        return documentBaseUrl;
+    }
+    // Entry scripts remain under the public deployment base when an SPA route
+    // changes document.baseURI. This covers Vite and common UMI/Webpack layouts.
+    for (const script of Array.from(documentRef.querySelectorAll('script[src]'))) {
+        try {
+            const scriptUrl = new URL(script.src || script.getAttribute('src') || '', documentBaseUrl);
+            const assetDirectory = scriptUrl.pathname.match(/^(.*\/)(?:assets|static)\/[^/]+$/i);
+            if (assetDirectory) {
+                return new URL(assetDirectory[1], scriptUrl.origin).href;
+            }
+            if (/\/(?:umi|main|index)(?:[.-][^/]*)?\.(?:m?js)$/i.test(scriptUrl.pathname)) {
+                return new URL('./', scriptUrl).href;
+            }
+        }
+        catch {
+            // Ignore unrelated or malformed script URLs.
+        }
+    }
+    return documentBaseUrl;
 };
 const buildOutlineItems = (items, prefix = 'outline', getFallbackTitle = index => `Outline ${index + 1}`) => items.map((item, index) => {
     const id = `${prefix}-${index}`;
@@ -218,6 +321,10 @@ export default async function renderPdf(buffer, target, context) {
         throw new Error(t('pdf.error.browserWindow'));
     }
     const options = (_a = context === null || context === void 0 ? void 0 : context.options) === null || _a === void 0 ? void 0 : _a.pdf;
+    const pdfRuntimeAssetBaseUrl = resolvePdfRuntimeAssetBaseUrl(documentRef);
+    const cjkFontFallbackEnabled = (options === null || options === void 0 ? void 0 : options.cjkFontFallback) !== false;
+    const identityFontRepairEnabled = (options === null || options === void 0 ? void 0 : options.identityFontRepair) !== false;
+    const fontInspectionEnabled = cjkFontFallbackEnabled || identityFontRepairEnabled;
     const initialViewState = (options === null || options === void 0 ? void 0 : options.initialViewState) || ((_b = context === null || context === void 0 ? void 0 : context.options) === null || _b === void 0 ? void 0 : _b.initialViewState) || null;
     const navigationEnabled = (options === null || options === void 0 ? void 0 : options.navigation) !== false;
     const toolbarVisible = (options === null || options === void 0 ? void 0 : options.toolbar) !== false;
@@ -260,6 +367,10 @@ export default async function renderPdf(buffer, target, context) {
     let pdfSearchWaiters = [];
     const pdfThumbnails = new Map();
     const pendingPdfThumbnails = new Set();
+    const pdfCjkFontFallbackPageLoads = new Map();
+    const pdfCjkFontFallbackRenderHandledPages = new Set();
+    let pdfCjkFontFallbackManager = null;
+    let restorePdfJsMissingSystemFontWarnings = () => { };
     const pdfContext = {
         viewer: null,
         linkService: null,
@@ -269,6 +380,17 @@ export default async function renderPdf(buffer, target, context) {
         document: null,
         search: '',
     };
+    const ensurePdfPageCjkFontFallback = (pageNumber, page) => {
+        if (!pdfCjkFontFallbackManager) {
+            return Promise.resolve(false);
+        }
+        let pending = pdfCjkFontFallbackPageLoads.get(pageNumber);
+        if (!pending) {
+            pending = pdfCjkFontFallbackManager.ensurePage(page);
+            pdfCjkFontFallbackPageLoads.set(pageNumber, pending);
+        }
+        return pending;
+    };
     const root = createElement(documentRef, 'div', 'pdf-shell');
     root.dataset.viewerSearchProvider = 'pdf';
     root.dataset.viewerZoomProvider = 'pdf';
@@ -426,6 +548,7 @@ export default async function renderPdf(buffer, target, context) {
             if (destroyed || pdfContext.document !== pdfDocument) {
                 return;
             }
+            await ensurePdfPageCjkFontFallback(pageNumber, page);
             const baseViewport = page.getViewport({
                 scale: PixelsPerInch.PDF_TO_CSS_UNITS,
                 rotation: currentRotation,
@@ -597,14 +720,16 @@ export default async function renderPdf(buffer, target, context) {
         }
     };
     const createPdfWorker = async () => {
-        const workerUrl = resolvePdfWorkerUrl(options, documentRef.URL || undefined);
+        const workerUrl = resolvePdfWorkerUrl(options, pdfRuntimeAssetBaseUrl);
         const hasExplicitWorkerUrl = isConfiguredUrl(options === null || options === void 0 ? void 0 : options.workerUrl);
         const shouldUseRealWorker = !!(targetWindow === null || targetWindow === void 0 ? void 0 : targetWindow.Worker) &&
             (hasExplicitWorkerUrl || await canUseResolvedPdfWorkerUrl(workerUrl));
         if (shouldUseRealWorker) {
             GlobalWorkerOptions.workerSrc = workerUrl;
             try {
-                const worker = PdfJsWorker.create({ name: 'file-viewer-pdf-worker' });
+                const worker = new PdfJsWorker({
+                    name: 'file-viewer-pdf-worker',
+                });
                 await worker.promise;
                 return worker;
             }
@@ -1193,6 +1318,7 @@ export default async function renderPdf(buffer, target, context) {
                 throw new Error(t('pdf.error.unloaded'));
             }
             const page = await pdfDocument.getPage(pageNumber);
+            await ensurePdfPageCjkFontFallback(pageNumber, page);
             const baseViewport = page.getViewport({
                 scale: PixelsPerInch.PDF_TO_CSS_UNITS,
                 rotation: currentRotation,
@@ -1227,8 +1353,13 @@ export default async function renderPdf(buffer, target, context) {
         return `<div class="pdf-export-document">${pagesHtml.join('')}</div>`;
     };
     const loadFile = async () => {
-        var _a, _b;
+        var _a, _b, _c;
         const requestVersion = ++loadVersion;
+        restorePdfJsMissingSystemFontWarnings();
+        restorePdfJsMissingSystemFontWarnings = () => { };
+        pdfCjkFontFallbackManager = null;
+        pdfCjkFontFallbackPageLoads.clear();
+        pdfCjkFontFallbackRenderHandledPages.clear();
         loadStatus = 'loading';
         errorMessage = '';
         pdfContext.document = null;
@@ -1313,12 +1444,46 @@ export default async function renderPdf(buffer, target, context) {
                     emitViewStateChange('zoom-change', 'viewer');
                 }
             });
-            eventBus.on('pagerendered', scheduleLegacyPageDimensionPatch);
+            eventBus.on('pagerendered', ({ pageNumber }) => {
+                scheduleLegacyPageDimensionPatch();
+                if (!pdfCjkFontFallbackManager ||
+                    pdfCjkFontFallbackRenderHandledPages.has(pageNumber)) {
+                    return;
+                }
+                pdfCjkFontFallbackRenderHandledPages.add(pageNumber);
+                const pdfDocument = pdfContext.document;
+                const alreadyPrepared = pdfCjkFontFallbackPageLoads.has(pageNumber);
+                if (!pdfDocument || alreadyPrepared) {
+                    return;
+                }
+                void pdfDocument.getPage(pageNumber)
+                    .then(page => ensurePdfPageCjkFontFallback(pageNumber, page))
+                    .then(fontLoaded => {
+                    var _a;
+                    if (fontLoaded &&
+                        !destroyed &&
+                        pdfContext.document === pdfDocument) {
+                        (_a = pdfContext.viewer) === null || _a === void 0 ? void 0 : _a.refresh();
+                    }
+                })
+                    .catch(error => {
+                    console.warn('[file-viewer] Unable to inspect a PDF page for CJK font fallback.', error);
+                });
+            });
             if (!(context === null || context === void 0 ? void 0 : context.streamUrl) && !buffer.byteLength) {
                 throw new Error(t('pdf.error.missingSource'));
             }
-            const worker = await createPdfWorker();
-            const pdfAssets = resolveFileViewerPdfAssetUrls(options, documentRef.URL || documentRef.baseURI);
+            const pdfAssets = resolveFileViewerPdfAssetUrls(options, pdfRuntimeAssetBaseUrl);
+            if (cjkFontFallbackEnabled) {
+                pdfCjkFontFallbackManager = createPdfCjkFontFallbackManager({
+                    documentRef,
+                    fontAssetPath: pdfAssets.cjkFontFallbackPath,
+                    onWarning: (message, error) => {
+                        console.warn(`[file-viewer] ${message}`, error || '');
+                    },
+                });
+                restorePdfJsMissingSystemFontWarnings = suppressPdfJsMissingSystemFontWarnings(targetWindow);
+            }
             const source = (context === null || context === void 0 ? void 0 : context.streamUrl)
                 ? {
                     url: context.streamUrl,
@@ -1328,19 +1493,24 @@ export default async function renderPdf(buffer, target, context) {
                 : {
                     data: buffer,
                 };
-            const loadingTask = getDocument({
-                ...source,
-                worker: worker || undefined,
-                cMapUrl: pdfAssets.cMapUrl,
-                wasmUrl: pdfAssets.wasmUrl,
-                standardFontDataUrl: pdfAssets.standardFontDataUrl,
-                useWorkerFetch: true,
-                cMapPacked: true,
-                enableXfa: true,
-            });
-            resource = { loadingTask, worker };
+            const createLoadingResource = async (loadingSource) => {
+                const worker = await createPdfWorker();
+                const loadingTask = getDocument({
+                    ...loadingSource,
+                    worker: worker || undefined,
+                    cMapUrl: pdfAssets.cMapUrl,
+                    wasmUrl: pdfAssets.wasmUrl,
+                    standardFontDataUrl: pdfAssets.standardFontDataUrl,
+                    useWorkerFetch: true,
+                    cMapPacked: true,
+                    enableXfa: true,
+                    fontExtraProperties: fontInspectionEnabled,
+                });
+                return { loadingTask, worker };
+            };
+            resource = await createLoadingResource(source);
             pdfContext.resource = resource;
-            const pdfDocument = await loadingTask.promise;
+            let pdfDocument = await resource.loadingTask.promise;
             if (destroyed || requestVersion !== loadVersion || pdfContext.resource !== resource) {
                 if (pdfContext.resource === resource) {
                     pdfContext.resource = null;
@@ -1348,10 +1518,86 @@ export default async function renderPdf(buffer, target, context) {
                 }
                 return;
             }
+            let firstPageTextContent = null;
+            let firstPageForInspection = null;
+            if (fontInspectionEnabled && pdfDocument.numPages > 0) {
+                const firstPage = await pdfDocument.getPage(1);
+                firstPageForInspection = firstPage;
+                firstPageTextContent = await firstPageForInspection.getTextContent();
+            }
+            if (identityFontRepairEnabled && firstPageTextContent) {
+                const malformedFontNames = collectMalformedIdentityFontNames(firstPageTextContent);
+                if (malformedFontNames.length && firstPageForInspection) {
+                    await firstPageForInspection.getOperatorList();
+                }
+                const malformedFontFamilies = new Map();
+                for (const fontName of malformedFontNames) {
+                    try {
+                        const family = (_b = firstPageForInspection === null || firstPageForInspection === void 0 ? void 0 : firstPageForInspection.commonObjs.get(fontName)) === null || _b === void 0 ? void 0 : _b.name;
+                        if (family) {
+                            malformedFontFamilies.set(fontName, family);
+                        }
+                    }
+                    catch {
+                        // A font object that is still unresolved cannot be repaired safely.
+                    }
+                }
+                const candidateFamilies = detectMalformedIdentityCjkFontFamilies(firstPageTextContent, fontName => malformedFontFamilies.get(fontName) || '');
+                if (candidateFamilies.length) {
+                    let replacementResource = null;
+                    try {
+                        const sourceBytes = await pdfDocument.getData();
+                        const { repairMalformedIdentityCjkFonts } = await import('./pdfIdentityFontRepair.js');
+                        const repaired = await repairMalformedIdentityCjkFonts(sourceBytes, candidateFamilies);
+                        if (repaired.repairedFonts > 0) {
+                            const previousResource = resource;
+                            replacementResource = await createLoadingResource({ data: repaired.bytes });
+                            const replacementDocument = await replacementResource.loadingTask.promise;
+                            const repairedFirstPage = await replacementDocument.getPage(1);
+                            const replacementTextContent = await repairedFirstPage.getTextContent();
+                            if (destroyed ||
+                                requestVersion !== loadVersion ||
+                                pdfContext.resource !== previousResource) {
+                                await destroyPdfResource(replacementResource);
+                                return;
+                            }
+                            resource = replacementResource;
+                            replacementResource = null;
+                            pdfContext.resource = resource;
+                            pdfDocument = replacementDocument;
+                            firstPageTextContent = replacementTextContent;
+                            await destroyPdfResource(previousResource);
+                            console.info(`[file-viewer] Repaired ${repaired.repairedFonts} malformed PDF Identity CJK font mapping(s).`);
+                        }
+                    }
+                    catch (error) {
+                        if (replacementResource) {
+                            await destroyPdfResource(replacementResource);
+                        }
+                        console.warn('[file-viewer] Unable to repair a malformed PDF Identity CJK font; continuing with the original preview.', error);
+                    }
+                }
+            }
+            if (destroyed || requestVersion !== loadVersion || pdfContext.resource !== resource) {
+                return;
+            }
             pageCount = pdfDocument.numPages;
             currentPage = 1;
             pdfContext.document = pdfDocument;
-            (_b = context === null || context === void 0 ? void 0 : context.registerExportAdapter) === null || _b === void 0 ? void 0 : _b.call(context, {
+            if (pdfCjkFontFallbackManager && pageCount > 0) {
+                if (firstPageTextContent) {
+                    pdfCjkFontFallbackPageLoads.set(1, pdfCjkFontFallbackManager.ensureTextContent(firstPageTextContent));
+                    await pdfCjkFontFallbackPageLoads.get(1);
+                }
+                else {
+                    const firstPage = await pdfDocument.getPage(1);
+                    await ensurePdfPageCjkFontFallback(1, firstPage);
+                }
+                if (destroyed || requestVersion !== loadVersion || pdfContext.document !== pdfDocument) {
+                    return;
+                }
+            }
+            (_c = context === null || context === void 0 ? void 0 : context.registerExportAdapter) === null || _c === void 0 ? void 0 : _c.call(context, {
                 includeDocumentStyles: false,
                 printStyle: buildPdfPrintStyle,
                 toHtml: renderPdfPagesForExport,
@@ -1436,6 +1682,11 @@ export default async function renderPdf(buffer, target, context) {
             var _a;
             destroyed = true;
             loadVersion += 1;
+            restorePdfJsMissingSystemFontWarnings();
+            restorePdfJsMissingSystemFontWarnings = () => { };
+            pdfCjkFontFallbackManager = null;
+            pdfCjkFontFallbackPageLoads.clear();
+            pdfCjkFontFallbackRenderHandledPages.clear();
             targetWindow.cancelAnimationFrame(fitFrame);
             targetWindow.cancelAnimationFrame(pageDimensionFrame);
             targetWindow.cancelAnimationFrame(scrollStateFrame);

package/dist/pdfFontFallback.d.ts

@@ -0,0 +1,33 @@
+type PdfTextContentItem = {
+    str?: string;
+    fontName?: string;
+};
+type PdfTextContentStyle = {
+    fontSubstitution?: string;
+};
+export type PdfTextContent = {
+    items?: PdfTextContentItem[];
+    styles?: Record<string, PdfTextContentStyle>;
+};
+export type PdfTextContentPage = {
+    getTextContent: () => Promise<PdfTextContent>;
+};
+export interface PdfCjkFontFallbackManager {
+    prepare: () => Promise<boolean>;
+    ensureTextContent: (textContent: PdfTextContent) => Promise<boolean>;
+    ensurePage: (page: PdfTextContentPage) => Promise<boolean>;
+}
+export interface CreatePdfCjkFontFallbackManagerOptions {
+    documentRef: Document;
+    fontAssetPath: string;
+    onWarning?: (message: string, error?: unknown) => void;
+}
+/**
+ * Some PDF generators write TrueType glyph IDs through Identity-H but omit
+ * ToUnicode. PDF.js then exposes those glyph IDs as control characters, so a
+ * replacement font alone cannot recover the intended text.
+ */
+export declare const detectMalformedIdentityCjkFontFamilies: (textContent: PdfTextContent, resolveFontFamily?: (fontName: string) => string) => string[];
+export declare const collectMalformedIdentityFontNames: (textContent: PdfTextContent) => string[];
+export declare const createPdfCjkFontFallbackManager: ({ documentRef, fontAssetPath, onWarning, }: CreatePdfCjkFontFallbackManagerOptions) => PdfCjkFontFallbackManager;
+export {};

package/dist/pdfFontFallback.js

@@ -0,0 +1,282 @@
+const PDF_CJK_FONT_CSS_FILE = 'noto-sans-sc.css';
+const PDF_CJK_FONT_TEMPLATE_FAMILY = 'Noto Sans SC Variable';
+const PDF_CJK_TEXT_RE = /[\u2e80-\u2fff\u3000-\u303f\u3040-\u30ff\u3100-\u312f\u31a0-\u31bf\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\uff00-\uffef]/;
+const PDF_CONTROL_TEXT_RE = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g;
+const PDF_CJK_FONT_MAX_PROBE_CHARS = 4096;
+const PDF_IDENTITY_FONT_MIN_CONTROL_CHARS = 2;
+const fontTemplatePromises = new Map();
+const fontDocumentStates = new WeakMap();
+const escapeCssString = (value) => value
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/[\r\n\f]/g, ' ');
+const unescapeCssString = (value) => value
+    .replace(/\\([\\"'])/g, '$1')
+    .trim();
+const normalizeFontFamilyKey = (value) => value
+    .normalize('NFKC')
+    .toLowerCase()
+    .replace(/[\s_,-]+/g, '');
+const PDF_CJK_LOCAL_FONT_CANDIDATES = {
+    microsoftyahei: ['Microsoft YaHei', 'Microsoft YaHei UI', '微软雅黑'],
+    microsoftyaheiui: ['Microsoft YaHei UI', 'Microsoft YaHei', '微软雅黑'],
+    simhei: ['SimHei', 'Heiti SC', '黑体', '黑体-简'],
+    simsun: ['SimSun', 'NSimSun', 'Songti SC', '宋体', '宋体-简'],
+    kaiti: ['KaiTi', 'STKaiti', '楷体'],
+    fangsong: ['FangSong', 'STFangsong', '仿宋'],
+    pingfangsc: ['PingFang SC', 'Hiragino Sans GB', 'Heiti SC'],
+    notosanscjksc: ['Noto Sans CJK SC', 'Source Han Sans SC'],
+    sourcehansanssc: ['Source Han Sans SC', 'Noto Sans CJK SC'],
+    arialunicodems: ['Arial Unicode MS'],
+};
+const getLocalFontCandidates = (family) => {
+    const candidates = [family, ...(PDF_CJK_LOCAL_FONT_CANDIDATES[normalizeFontFamilyKey(family)] || [])];
+    return [...new Set(candidates.filter(Boolean))];
+};
+const resolveFontCssUrl = (fontAssetPath) => {
+    const normalizedPath = fontAssetPath.endsWith('/') ? fontAssetPath : `${fontAssetPath}/`;
+    return new URL(PDF_CJK_FONT_CSS_FILE, normalizedPath).href;
+};
+const resolveFontTemplateUrls = (css, cssUrl) => css.replace(/url\(\s*(['"]?)(\.\/files\/[^'"\s)]+)\1\s*\)/g, (_match, _quote, relativeUrl) => {
+    const absoluteUrl = escapeCssString(new URL(relativeUrl, cssUrl).href);
+    return `url("${absoluteUrl}")`;
+});
+const loadFontTemplate = (documentRef, cssUrl) => {
+    var _a;
+    const cached = fontTemplatePromises.get(cssUrl);
+    if (cached) {
+        return cached;
+    }
+    const view = documentRef.defaultView;
+    const fetcher = ((_a = view === null || view === void 0 ? void 0 : view.fetch) === null || _a === void 0 ? void 0 : _a.bind(view)) || globalThis.fetch;
+    const promise = fetcher(cssUrl, { credentials: 'same-origin' })
+        .then(async (response) => {
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status} while loading ${cssUrl}`);
+        }
+        const css = await response.text();
+        if (!css.includes(PDF_CJK_FONT_TEMPLATE_FAMILY) || !css.includes('./files/')) {
+            throw new Error(`Invalid PDF CJK font fallback stylesheet: ${cssUrl}`);
+        }
+        return resolveFontTemplateUrls(css, cssUrl);
+    })
+        .catch(error => {
+        fontTemplatePromises.delete(cssUrl);
+        throw error;
+    });
+    fontTemplatePromises.set(cssUrl, promise);
+    return promise;
+};
+const getDocumentState = (documentRef, cssUrl) => {
+    let states = fontDocumentStates.get(documentRef);
+    if (!states) {
+        states = new Map();
+        fontDocumentStates.set(documentRef, states);
+    }
+    let state = states.get(cssUrl);
+    if (!state) {
+        state = { families: new Map() };
+        states.set(cssUrl, state);
+    }
+    return state;
+};
+const extractSubstitutionFamily = (value) => {
+    if (!value) {
+        return '';
+    }
+    const match = value.match(/^\s*(?:"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)'|([^,]+))/);
+    const family = unescapeCssString((match === null || match === void 0 ? void 0 : match[1]) || (match === null || match === void 0 ? void 0 : match[2]) || (match === null || match === void 0 ? void 0 : match[3]) || '');
+    if (!family ||
+        family.length > 160 ||
+        /[\u0000-\u001f\u007f]/.test(family) ||
+        /^(?:serif|sans-serif|monospace|cursive|fantasy|system-ui)$/i.test(family)) {
+        return '';
+    }
+    return family;
+};
+const isKnownCjkFontFamily = (family) => {
+    const key = normalizeFontFamilyKey(family);
+    return Boolean(PDF_CJK_LOCAL_FONT_CANDIDATES[key]) ||
+        /(?:cjk|han|song|hei|kai|fang|yahei|ming|gothic|mincho)/i.test(key) ||
+        /[\u3400-\u9fff]/.test(family);
+};
+/**
+ * Some PDF generators write TrueType glyph IDs through Identity-H but omit
+ * ToUnicode. PDF.js then exposes those glyph IDs as control characters, so a
+ * replacement font alone cannot recover the intended text.
+ */
+export const detectMalformedIdentityCjkFontFamilies = (textContent, resolveFontFamily = () => '') => {
+    var _a, _b;
+    const styles = textContent.styles || {};
+    const families = new Set();
+    for (const item of textContent.items || []) {
+        const text = item.str || '';
+        const controlChars = ((_a = text.match(PDF_CONTROL_TEXT_RE)) === null || _a === void 0 ? void 0 : _a.length) || 0;
+        if (controlChars < PDF_IDENTITY_FONT_MIN_CONTROL_CHARS) {
+            continue;
+        }
+        const fontName = item.fontName || '';
+        const resolvedFamily = resolveFontFamily(fontName);
+        const safeResolvedFamily = resolvedFamily.length <= 160 &&
+            !/[\u0000-\u001f\u007f]/.test(resolvedFamily)
+            ? resolvedFamily
+            : '';
+        const family = extractSubstitutionFamily((_b = styles[fontName]) === null || _b === void 0 ? void 0 : _b.fontSubstitution) ||
+            safeResolvedFamily;
+        if (family && isKnownCjkFontFamily(family)) {
+            families.add(family);
+        }
+    }
+    return [...families];
+};
+export const collectMalformedIdentityFontNames = (textContent) => {
+    var _a;
+    const fontNames = new Set();
+    for (const item of textContent.items || []) {
+        const controlChars = ((_a = (item.str || '').match(PDF_CONTROL_TEXT_RE)) === null || _a === void 0 ? void 0 : _a.length) || 0;
+        if (controlChars >= PDF_IDENTITY_FONT_MIN_CONTROL_CHARS && item.fontName) {
+            fontNames.add(item.fontName);
+        }
+    }
+    return [...fontNames];
+};
+const collectPageFontText = (textContent) => {
+    var _a;
+    const styles = textContent.styles || {};
+    const familyChars = new Map();
+    let totalChars = 0;
+    for (const item of textContent.items || []) {
+        const text = item.str || '';
+        if (!PDF_CJK_TEXT_RE.test(text)) {
+            continue;
+        }
+        const family = extractSubstitutionFamily((_a = styles[item.fontName || '']) === null || _a === void 0 ? void 0 : _a.fontSubstitution);
+        if (!family) {
+            continue;
+        }
+        let chars = familyChars.get(family);
+        if (!chars) {
+            chars = new Set();
+            familyChars.set(family, chars);
+        }
+        for (const char of text) {
+            if (!/[\u0000-\u001f\u007f]/.test(char) && !chars.has(char)) {
+                chars.add(char);
+                totalChars += 1;
+                if (totalChars >= PDF_CJK_FONT_MAX_PROBE_CHARS) {
+                    return familyChars;
+                }
+            }
+        }
+    }
+    return familyChars;
+};
+const createAliasStylesheet = (template, family) => {
+    const escapedFamily = escapeCssString(family);
+    const localSources = getLocalFontCandidates(family)
+        .map(candidate => `local("${escapeCssString(candidate)}")`)
+        .join(', ');
+    return template
+        .replace(/font-family:\s*'Noto Sans SC Variable';/g, `font-family: "${escapedFamily}";`)
+        .replace(/font-display:\s*swap;/g, 'font-display: block;')
+        .replace(/src:\s*url\(/g, `src: ${localSources}, url(`);
+};
+const ensureAliasStyle = (documentRef, state, template, family) => {
+    if (state.styleInjected) {
+        return;
+    }
+    const style = documentRef.createElement('style');
+    style.dataset.fileViewerPdfCjkFallbackFamily = family;
+    style.textContent = createAliasStylesheet(template, family);
+    (documentRef.head || documentRef.documentElement).append(style);
+    state.styleInjected = true;
+};
+const loadFamilyText = async (documentRef, documentState, template, family, chars) => {
+    let state = documentState.families.get(family);
+    if (!state) {
+        state = {
+            loadedChars: new Set(),
+            tail: Promise.resolve(),
+            styleInjected: false,
+        };
+        documentState.families.set(family, state);
+    }
+    ensureAliasStyle(documentRef, state, template, family);
+    const pendingChars = [...chars].filter(char => !state.loadedChars.has(char));
+    if (!pendingChars.length) {
+        return false;
+    }
+    pendingChars.forEach(char => state === null || state === void 0 ? void 0 : state.loadedChars.add(char));
+    const probeText = pendingChars.join('');
+    const escapedFamily = escapeCssString(family);
+    const fontSet = documentRef.fonts;
+    if (!(fontSet === null || fontSet === void 0 ? void 0 : fontSet.load)) {
+        return true;
+    }
+    const operation = state.tail.then(async () => {
+        const loadedFaces = await Promise.all([
+            fontSet.load(`normal 400 16px "${escapedFamily}"`, probeText),
+            fontSet.load(`normal 700 16px "${escapedFamily}"`, probeText),
+        ]);
+        if (!loadedFaces.some(faces => faces.length > 0)) {
+            throw new Error(`No matching CJK fallback font face loaded for ${family}`);
+        }
+    });
+    state.tail = operation.catch(() => { });
+    try {
+        await operation;
+        return true;
+    }
+    catch (error) {
+        pendingChars.forEach(char => state === null || state === void 0 ? void 0 : state.loadedChars.delete(char));
+        throw error;
+    }
+};
+export const createPdfCjkFontFallbackManager = ({ documentRef, fontAssetPath, onWarning, }) => {
+    const cssUrl = resolveFontCssUrl(fontAssetPath);
+    const documentState = getDocumentState(documentRef, cssUrl);
+    let templatePromise = null;
+    let warningReported = false;
+    const warnOnce = (message, error) => {
+        if (warningReported) {
+            return;
+        }
+        warningReported = true;
+        onWarning === null || onWarning === void 0 ? void 0 : onWarning(message, error);
+    };
+    const getTemplate = () => {
+        templatePromise || (templatePromise = loadFontTemplate(documentRef, cssUrl));
+        return templatePromise;
+    };
+    const ensureTextContent = async (textContent) => {
+        try {
+            const familyChars = collectPageFontText(textContent);
+            if (!familyChars.size) {
+                return false;
+            }
+            const template = await getTemplate();
+            const results = await Promise.all([...familyChars].map(([family, chars]) => (loadFamilyText(documentRef, documentState, template, family, chars))));
+            return results.some(Boolean);
+        }
+        catch (error) {
+            warnOnce('Unable to load an offline fallback for an unembedded PDF CJK font.', error);
+            return false;
+        }
+    };
+    return {
+        async prepare() {
+            try {
+                await getTemplate();
+                return true;
+            }
+            catch (error) {
+                warnOnce(`Unable to load the offline PDF CJK font fallback from ${cssUrl}.`, error);
+                return false;
+            }
+        },
+        ensureTextContent,
+        async ensurePage(page) {
+            return ensureTextContent(await page.getTextContent());
+        },
+    };
+};

package/dist/pdfIdentityFontRepair.d.ts

@@ -0,0 +1,6 @@
+export type PdfIdentityFontRepairResult = {
+    bytes: Uint8Array;
+    repairedFonts: number;
+    repairedFamilies: string[];
+};
+export declare const repairMalformedIdentityCjkFonts: (sourceBytes: Uint8Array, candidateFamilies?: readonly string[]) => Promise<PdfIdentityFontRepairResult>;

package/dist/pdfIdentityFontRepair.js

@@ -0,0 +1,452 @@
+import { decodePDFRawStream, PDFArray, PDFDict, PDFDocument, PDFHexString, PDFName, PDFNumber, PDFRawStream, PDFString, } from 'pdf-lib';
+const MAX_REPAIR_SOURCE_BYTES = 64 * 1024 * 1024;
+const MAX_TTF_TABLES = 256;
+const MAX_CMAP_GLYPHS = 0xffff;
+const MAX_CMAP_CODEPOINT_VISITS = 0x10000;
+const MAX_DECODED_FONT_BYTES = 64 * 1024 * 1024;
+const CMAP_BFCHAR_CHUNK_SIZE = 100;
+const BASE_FONT = PDFName.of('BaseFont');
+const CID_TO_GID_MAP = PDFName.of('CIDToGIDMap');
+const DESCENDANT_FONTS = PDFName.of('DescendantFonts');
+const ENCODING = PDFName.of('Encoding');
+const FONT = PDFName.of('Font');
+const FONT_DESCRIPTOR = PDFName.of('FontDescriptor');
+const FONT_FAMILY = PDFName.of('FontFamily');
+const FONT_FILE_2 = PDFName.of('FontFile2');
+const LENGTH_1 = PDFName.of('Length1');
+const RESOURCES = PDFName.of('Resources');
+const SUBTYPE = PDFName.of('Subtype');
+const TO_UNICODE = PDFName.of('ToUnicode');
+const X_OBJECT = PDFName.of('XObject');
+const CJK_FONT_FAMILY_ALIASES = {
+    '微软雅黑': 'microsoftyahei',
+    '宋体': 'simsun',
+    '黑体': 'simhei',
+    '楷体': 'kaiti',
+    '仿宋': 'fangsong',
+};
+const CJK_FONT_FAMILY_MARKERS = [
+    'microsoftyahei',
+    'simsun',
+    'nsimsun',
+    'simhei',
+    'kaiti',
+    'fangsong',
+    'pingfang',
+    'songti',
+    'heiti',
+    'hiragino',
+    'notosanscjk',
+    'sourcehansans',
+    'sourcehanserif',
+];
+const readUint16 = (bytes, offset) => {
+    if (offset < 0 || offset + 2 > bytes.length) {
+        throw new Error('Unexpected end of TrueType font data.');
+    }
+    return (bytes[offset] << 8) | bytes[offset + 1];
+};
+const readUint32 = (bytes, offset) => {
+    if (offset < 0 || offset + 4 > bytes.length) {
+        throw new Error('Unexpected end of TrueType font data.');
+    }
+    return (bytes[offset] * 0x1000000 +
+        (bytes[offset + 1] << 16) +
+        (bytes[offset + 2] << 8) +
+        bytes[offset + 3]) >>> 0;
+};
+const readTag = (bytes, offset) => {
+    if (offset < 0 || offset + 4 > bytes.length) {
+        return '';
+    }
+    return String.fromCharCode(bytes[offset], bytes[offset + 1], bytes[offset + 2], bytes[offset + 3]);
+};
+const normalizeFontFamily = (value) => {
+    const withoutSubset = value.replace(/^[A-Z]{6}\+/i, '');
+    const withoutStyle = withoutSubset.replace(/(?:[\s,_-]+)(?:bold|regular|italic|oblique|medium|semibold|demibold|light|black|thin)(?:mt)?(?:[\s,_-].*)?$/i, '');
+    const normalized = withoutStyle
+        .normalize('NFKC')
+        .toLowerCase()
+        .replace(/[\s,_-]+/g, '');
+    return CJK_FONT_FAMILY_ALIASES[normalized] || normalized;
+};
+const isCjkFontFamily = (family) => {
+    const key = normalizeFontFamily(family);
+    return CJK_FONT_FAMILY_MARKERS.some(marker => key.includes(marker)) ||
+        /[\u3400-\u9fff]/.test(family);
+};
+const readFontName = (font) => {
+    var _a;
+    return ((_a = font.lookupMaybe(BASE_FONT, PDFName)) === null || _a === void 0 ? void 0 : _a.decodeText()) || '';
+};
+const readFontFamily = (descriptor) => {
+    var _a;
+    if (!descriptor) {
+        return '';
+    }
+    return ((_a = descriptor.lookupMaybe(FONT_FAMILY, PDFString, PDFHexString)) === null || _a === void 0 ? void 0 : _a.decodeText()) || '';
+};
+const getDescendantFont = (font) => {
+    var _a;
+    return (_a = font.lookupMaybe(DESCENDANT_FONTS, PDFArray)) === null || _a === void 0 ? void 0 : _a.lookupMaybe(0, PDFDict);
+};
+const getEmbeddedTrueTypeFont = (descriptor) => {
+    var _a;
+    if (!descriptor) {
+        return undefined;
+    }
+    const fontFile = descriptor.get(FONT_FILE_2);
+    if (!fontFile) {
+        return undefined;
+    }
+    const resolved = descriptor.context.lookup(fontFile);
+    if (!(resolved instanceof PDFRawStream)) {
+        return undefined;
+    }
+    const declaredLength = (_a = resolved.dict.lookupMaybe(LENGTH_1, PDFNumber)) === null || _a === void 0 ? void 0 : _a.asNumber();
+    if (typeof declaredLength !== 'number' ||
+        !Number.isSafeInteger(declaredLength) ||
+        declaredLength < 1 ||
+        declaredLength > MAX_DECODED_FONT_BYTES ||
+        resolved.contents.byteLength > MAX_DECODED_FONT_BYTES) {
+        return undefined;
+    }
+    return resolved;
+};
+const createFontRecord = (font) => {
+    var _a;
+    const descendant = getDescendantFont(font);
+    if (!descendant) {
+        return null;
+    }
+    const encoding = (_a = font.lookupMaybe(ENCODING, PDFName)) === null || _a === void 0 ? void 0 : _a.decodeText();
+    if (encoding !== 'Identity-H' && encoding !== 'Identity-V') {
+        return null;
+    }
+    const descriptor = descendant.lookupMaybe(FONT_DESCRIPTOR, PDFDict);
+    const baseFont = readFontName(font);
+    const descriptorFamily = readFontFamily(descriptor);
+    const cidToGidMapObject = descendant.get(CID_TO_GID_MAP);
+    const cidToGidMap = cidToGidMapObject
+        ? descendant.context.lookup(cidToGidMapObject)
+        : undefined;
+    const familyKeys = new Set([baseFont, descriptorFamily]
+        .filter(Boolean)
+        .map(normalizeFontFamily)
+        .filter(Boolean));
+    return {
+        font,
+        descendant,
+        familyKeys,
+        baseFont,
+        identityCidToGidMap: !cidToGidMap ||
+            (cidToGidMap instanceof PDFName && cidToGidMap.decodeText() === 'Identity'),
+        embeddedFont: getEmbeddedTrueTypeFont(descriptor),
+    };
+};
+const collectFontRecords = (pdfDocument) => {
+    const records = new Map();
+    const visitedResources = new Set();
+    const visitedXObjects = new Set();
+    const visitResources = (resources) => {
+        var _a;
+        if (!resources || visitedResources.has(resources)) {
+            return;
+        }
+        visitedResources.add(resources);
+        const fonts = resources.lookupMaybe(FONT, PDFDict);
+        for (const fontObject of (fonts === null || fonts === void 0 ? void 0 : fonts.values()) || []) {
+            const font = pdfDocument.context.lookup(fontObject);
+            if (!(font instanceof PDFDict) || records.has(font)) {
+                continue;
+            }
+            const record = createFontRecord(font);
+            if (record) {
+                records.set(font, record);
+            }
+        }
+        const xObjects = resources.lookupMaybe(X_OBJECT, PDFDict);
+        for (const xObjectRef of (xObjects === null || xObjects === void 0 ? void 0 : xObjects.values()) || []) {
+            const xObject = pdfDocument.context.lookup(xObjectRef);
+            if (!(xObject instanceof PDFRawStream) || visitedXObjects.has(xObject)) {
+                continue;
+            }
+            visitedXObjects.add(xObject);
+            if (((_a = xObject.dict.lookupMaybe(SUBTYPE, PDFName)) === null || _a === void 0 ? void 0 : _a.decodeText()) !== 'Form') {
+                continue;
+            }
+            visitResources(xObject.dict.lookupMaybe(RESOURCES, PDFDict));
+        }
+    };
+    for (const page of pdfDocument.getPages()) {
+        visitResources(page.node.Resources());
+    }
+    return [...records.values()];
+};
+const findCmapTable = (fontBytes) => {
+    if (fontBytes.length < 12) {
+        throw new Error('Invalid TrueType font header.');
+    }
+    const tableCount = readUint16(fontBytes, 4);
+    if (tableCount < 1 || tableCount > MAX_TTF_TABLES) {
+        throw new Error(`Invalid TrueType table count: ${tableCount}.`);
+    }
+    let cmapOffset = -1;
+    for (let index = 0; index < tableCount; index += 1) {
+        const entryOffset = 12 + index * 16;
+        if (entryOffset + 16 > fontBytes.length) {
+            throw new Error('Invalid TrueType table directory.');
+        }
+        if (readTag(fontBytes, entryOffset) === 'cmap') {
+            cmapOffset = readUint32(fontBytes, entryOffset + 8);
+            break;
+        }
+    }
+    if (cmapOffset < 0 || cmapOffset + 4 > fontBytes.length) {
+        throw new Error('TrueType font does not contain a readable cmap table.');
+    }
+    const cmapCount = readUint16(fontBytes, cmapOffset + 2);
+    const tables = [];
+    for (let index = 0; index < cmapCount; index += 1) {
+        const recordOffset = cmapOffset + 4 + index * 8;
+        if (recordOffset + 8 > fontBytes.length) {
+            break;
+        }
+        const offset = cmapOffset + readUint32(fontBytes, recordOffset + 4);
+        if (offset + 2 > fontBytes.length) {
+            continue;
+        }
+        const format = readUint16(fontBytes, offset);
+        if (format === 4 || format === 12) {
+            tables.push({
+                offset,
+                format,
+                platformId: readUint16(fontBytes, recordOffset),
+                encodingId: readUint16(fontBytes, recordOffset + 2),
+            });
+        }
+    }
+    const score = (table) => (table.format === 12 ? 100 : 0) +
+        (table.platformId === 3 ? 20 : 0) +
+        (table.platformId === 0 ? 10 : 0) +
+        (table.encodingId === 10 ? 4 : 0) +
+        (table.encodingId === 1 ? 2 : 0);
+    const selected = tables.sort((left, right) => score(right) - score(left))[0];
+    if (!selected) {
+        throw new Error('TrueType font does not contain a supported Unicode cmap.');
+    }
+    return selected;
+};
+const setGlyphMapping = (map, glyphId, codePoint) => {
+    if (glyphId > 0 &&
+        glyphId <= MAX_CMAP_GLYPHS &&
+        codePoint > 0 &&
+        codePoint <= 0x10ffff &&
+        !map.has(glyphId)) {
+        map.set(glyphId, codePoint);
+    }
+};
+const parseFormat12Cmap = (fontBytes, table, glyphToUnicode) => {
+    const tableLength = readUint32(fontBytes, table.offset + 4);
+    const tableEnd = table.offset + tableLength;
+    const groupCount = readUint32(fontBytes, table.offset + 12);
+    if (tableLength < 16 ||
+        tableEnd > fontBytes.length ||
+        table.offset + 16 + groupCount * 12 > tableEnd) {
+        throw new Error('Invalid TrueType cmap format 12 groups.');
+    }
+    let visitedCodePoints = 0;
+    for (let index = 0; index < groupCount; index += 1) {
+        const offset = table.offset + 16 + index * 12;
+        const startCodePoint = readUint32(fontBytes, offset);
+        const endCodePoint = readUint32(fontBytes, offset + 4);
+        const startGlyphId = readUint32(fontBytes, offset + 8);
+        const length = Math.min(endCodePoint - startCodePoint + 1, MAX_CMAP_GLYPHS - startGlyphId + 1);
+        if (!Number.isSafeInteger(length) || length < 1) {
+            continue;
+        }
+        for (let innerIndex = 0; innerIndex < length; innerIndex += 1) {
+            if (visitedCodePoints >= MAX_CMAP_CODEPOINT_VISITS) {
+                return;
+            }
+            visitedCodePoints += 1;
+            setGlyphMapping(glyphToUnicode, startGlyphId + innerIndex, startCodePoint + innerIndex);
+        }
+    }
+};
+const parseFormat4Cmap = (fontBytes, table, glyphToUnicode) => {
+    const tableLength = readUint16(fontBytes, table.offset + 2);
+    const tableEnd = table.offset + tableLength;
+    const segmentCount = readUint16(fontBytes, table.offset + 6) / 2;
+    const endCodesOffset = table.offset + 14;
+    const startCodesOffset = endCodesOffset + segmentCount * 2 + 2;
+    const deltasOffset = startCodesOffset + segmentCount * 2;
+    const rangeOffsetsOffset = deltasOffset + segmentCount * 2;
+    if (!Number.isInteger(segmentCount) ||
+        segmentCount < 1 ||
+        tableLength < 16 ||
+        tableEnd > fontBytes.length ||
+        rangeOffsetsOffset + segmentCount * 2 > tableEnd) {
+        throw new Error('Invalid TrueType cmap format 4 segments.');
+    }
+    let visitedCodePoints = 0;
+    for (let index = 0; index < segmentCount; index += 1) {
+        const endCodePoint = readUint16(fontBytes, endCodesOffset + index * 2);
+        const startCodePoint = readUint16(fontBytes, startCodesOffset + index * 2);
+        const delta = readUint16(fontBytes, deltasOffset + index * 2);
+        const rangeOffset = readUint16(fontBytes, rangeOffsetsOffset + index * 2);
+        if (endCodePoint < startCodePoint) {
+            continue;
+        }
+        for (let codePoint = startCodePoint; codePoint <= endCodePoint && codePoint !== 0xffff; codePoint += 1) {
+            if (visitedCodePoints >= MAX_CMAP_CODEPOINT_VISITS) {
+                return;
+            }
+            visitedCodePoints += 1;
+            let glyphId = 0;
+            if (rangeOffset === 0) {
+                glyphId = (codePoint + delta) & 0xffff;
+            }
+            else {
+                const glyphOffset = rangeOffsetsOffset + index * 2 + rangeOffset +
+                    (codePoint - startCodePoint) * 2;
+                if (glyphOffset + 2 <= tableEnd) {
+                    glyphId = readUint16(fontBytes, glyphOffset);
+                    if (glyphId) {
+                        glyphId = (glyphId + delta) & 0xffff;
+                    }
+                }
+            }
+            setGlyphMapping(glyphToUnicode, glyphId, codePoint);
+        }
+    }
+};
+const parseTrueTypeGlyphToUnicode = (fontBytes) => {
+    const selected = findCmapTable(fontBytes);
+    const glyphToUnicode = new Map();
+    if (selected.format === 12) {
+        parseFormat12Cmap(fontBytes, selected, glyphToUnicode);
+    }
+    else {
+        parseFormat4Cmap(fontBytes, selected, glyphToUnicode);
+    }
+    return glyphToUnicode;
+};
+const toHex = (value, minLength = 4) => value.toString(16).toUpperCase().padStart(minLength, '0');
+const encodeUnicodeCodePoint = (codePoint) => {
+    if (codePoint <= 0xffff) {
+        return toHex(codePoint);
+    }
+    const offset = codePoint - 0x10000;
+    const highSurrogate = 0xd800 + (offset >> 10);
+    const lowSurrogate = 0xdc00 + (offset & 0x3ff);
+    return `${toHex(highSurrogate)}${toHex(lowSurrogate)}`;
+};
+const createToUnicodeCmap = (glyphToUnicode) => {
+    const entries = [...glyphToUnicode]
+        .filter(([glyphId, codePoint]) => glyphId > 0 && glyphId <= 0xffff &&
+        codePoint > 0 && codePoint <= 0x10ffff)
+        .sort(([left], [right]) => left - right);
+    const sections = [];
+    for (let index = 0; index < entries.length; index += CMAP_BFCHAR_CHUNK_SIZE) {
+        const chunk = entries.slice(index, index + CMAP_BFCHAR_CHUNK_SIZE);
+        sections.push([
+            `${chunk.length} beginbfchar`,
+            ...chunk.map(([glyphId, codePoint]) => `<${toHex(glyphId)}> <${encodeUnicodeCodePoint(codePoint)}>`),
+            'endbfchar',
+        ].join('\n'));
+    }
+    return [
+        '/CIDInit /ProcSet findresource begin',
+        '12 dict begin',
+        'begincmap',
+        '/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def',
+        '/CMapName /Adobe-Identity-UCS def',
+        '/CMapType 2 def',
+        '1 begincodespacerange',
+        '<0000> <FFFF>',
+        'endcodespacerange',
+        ...sections,
+        'endcmap',
+        'CMapName currentdict /CMap defineresource pop',
+        'end',
+        'end',
+    ].join('\n');
+};
+const familiesOverlap = (left, right) => {
+    for (const key of left) {
+        if (right.has(key)) {
+            return true;
+        }
+    }
+    return false;
+};
+export const repairMalformedIdentityCjkFonts = async (sourceBytes, candidateFamilies = []) => {
+    if (!sourceBytes.byteLength || sourceBytes.byteLength > MAX_REPAIR_SOURCE_BYTES) {
+        return { bytes: sourceBytes, repairedFonts: 0, repairedFamilies: [] };
+    }
+    const candidateKeys = new Set(candidateFamilies.map(normalizeFontFamily).filter(Boolean));
+    const pdfDocument = await PDFDocument.load(sourceBytes, {
+        updateMetadata: false,
+    });
+    const records = collectFontRecords(pdfDocument);
+    const sourceMaps = new Map();
+    const getSourceMap = (record) => {
+        const cached = sourceMaps.get(record);
+        if (cached) {
+            return cached;
+        }
+        if (!record.embeddedFont) {
+            return undefined;
+        }
+        const decoded = decodePDFRawStream(record.embeddedFont).decode();
+        if (decoded.byteLength > MAX_DECODED_FONT_BYTES) {
+            throw new Error('Embedded TrueType font exceeds the Identity repair limit.');
+        }
+        const glyphMap = parseTrueTypeGlyphToUnicode(decoded);
+        sourceMaps.set(record, glyphMap);
+        return glyphMap;
+    };
+    let repairedFonts = 0;
+    const repairedFamilies = new Set();
+    for (const target of records) {
+        if (target.font.has(TO_UNICODE) ||
+            target.embeddedFont ||
+            !target.identityCidToGidMap ||
+            ![...target.familyKeys].some(key => isCjkFontFamily(key)) ||
+            (candidateKeys.size > 0 && ![...target.familyKeys].some(key => candidateKeys.has(key)))) {
+            continue;
+        }
+        let bestMap;
+        for (const source of records) {
+            if (!source.embeddedFont || !familiesOverlap(target.familyKeys, source.familyKeys)) {
+                continue;
+            }
+            try {
+                const sourceMap = getSourceMap(source);
+                if (sourceMap && (!bestMap || sourceMap.size > bestMap.size)) {
+                    bestMap = sourceMap;
+                }
+            }
+            catch {
+                // A different same-family embedded font may still provide a valid cmap.
+            }
+        }
+        if (!bestMap || bestMap.size < 2) {
+            continue;
+        }
+        const cmap = createToUnicodeCmap(bestMap);
+        const cmapRef = pdfDocument.context.register(pdfDocument.context.flateStream(cmap));
+        target.font.set(TO_UNICODE, cmapRef);
+        repairedFonts += 1;
+        repairedFamilies.add(target.baseFont || [...target.familyKeys][0] || 'CJK font');
+    }
+    if (!repairedFonts) {
+        return { bytes: sourceBytes, repairedFonts: 0, repairedFamilies: [] };
+    }
+    return {
+        bytes: await pdfDocument.save({ useObjectStreams: true }),
+        repairedFonts,
+        repairedFamilies: [...repairedFamilies],
+    };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@file-viewer/renderer-pdf",
-  "version": "2.1.24",
+  "version": "2.1.26",
   "private": false,
   "type": "module",
   "description": "Standalone PDF renderer plugin for Flyfish File Viewer powered by PDF.js.",
@@ -54,8 +54,10 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@file-viewer/core": "2.1.24",
-    "pdfjs-dist": "^6.0.227"
+    "@file-viewer/core": "2.1.26",
+    "@fontsource-variable/noto-sans-sc": "5.2.10",
+    "pdf-lib": "1.17.1",
+    "pdfjs-dist": "5.4.624"
   },
   "devDependencies": {
     "typescript": "^6.0.3"