@file-viewer/thumbnail 2.1.26

package/LICENSE

@@ -0,0 +1,15 @@
+Apache License 2.0
+
+Copyright 2026 Flyfish File Viewer contributors
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.en.md

@@ -0,0 +1,36 @@
+# @file-viewer/thumbnail
+
+Browser thumbnail generation for Flyfish File Viewer. It reuses `createViewer()`, installed renderers, optional native thumbnail adapters, a bounded viewer pool, ordered batch results, and completion-order streaming.
+
+```bash
+pnpm add @file-viewer/thumbnail @file-viewer/preset-all
+```
+
+```ts
+import { createFileViewerThumbnailGenerator } from '@file-viewer/thumbnail'
+import allPreset from '@file-viewer/preset-all'
+
+const generator = createFileViewerThumbnailGenerator({
+  // Uses the same preset/renderers configuration as createViewer().
+  viewerOptions: { preset: allPreset },
+  concurrency: 2,
+})
+
+const result = await generator.generate({ file, filename: file.name })
+for await (const item of generator.generateStream(files)) {
+  if (item.ok) await upload(item.result.blob)
+}
+await generator.destroy()
+```
+
+Each item can override `width`, `height`, `format: 'webp' | 'jpeg' | 'png'`, `quality`, `fit`, `background`, `timeoutMs`, and `signal`. `generate()` returns the Blob, actual MIME type, renderer ID, duration, `embedded | provider-native | provider-dom | dom-fallback` strategy, and `degraded` state. Batch results remain input-ordered and isolate failures; stream results are completion-ordered, carry the original index, and keep pending Blob results bounded by the concurrency window.
+
+Failures use `FileViewerThumbnailError` with stable codes: `browser-required`, `unsupported`, `timeout`, `aborted`, `capture-failed`, `capture-unavailable`, `tainted-canvas`, `empty-output`, `destroyed`, and `invalid-options`.
+
+- Requires a real browser. Server applications must invoke it inside Chromium.
+- The string form `preset: 'all'` only works after a Vite plugin or preset side-effect import has registered it. Pass the imported preset object, as above, for bundler-neutral setup.
+- Embedded previews take priority over rendering. EPUB uses its declared cover; OOXML and 3MF use package thumbnail relationships; OpenDocument and XMind use their packaged thumbnails; and Apple Numbers uses its Quick Look thumbnail when present.
+- Missing, corrupt, empty, or undecodable embedded images safely fall back to renderer-native or first-content capture.
+- PDF and images use native capture; Office, OFD, and ebooks expose a first-content target when no embedded preview is available.
+- Other renderers use a DOM fallback and return `degraded: true`.
+- Source files and generated thumbnails are never persisted by this package.

package/README.md

@@ -0,0 +1,47 @@
+# @file-viewer/thumbnail
+
+Flyfish File Viewer 的浏览器缩略图生成器。它复用 `createViewer()`、已安装的 renderer 与可选的原生缩略图 adapter，支持固定并发、批量有序结果和低内存流式输出。
+
+```bash
+pnpm add @file-viewer/thumbnail @file-viewer/preset-all
+```
+
+```ts
+import { createFileViewerThumbnailGenerator } from '@file-viewer/thumbnail'
+import allPreset from '@file-viewer/preset-all'
+
+const generator = createFileViewerThumbnailGenerator({
+  // 与 createViewer() 使用相同的 preset/renderers 配置。
+  viewerOptions: { preset: allPreset },
+  concurrency: 2,
+  timeoutMs: 30_000,
+})
+
+const thumbnail = await generator.generate({
+  file,
+  filename: file.name,
+}, {
+  width: 320,
+  height: 240,
+  format: 'webp',
+  quality: 0.8,
+})
+
+for await (const item of generator.generateStream(files)) {
+  if (item.ok) await upload(item.result.blob)
+}
+
+await generator.destroy()
+```
+
+单项可覆盖 `width`、`height`、`format: 'webp' | 'jpeg' | 'png'`、`quality`、`fit`、`background`、`timeoutMs` 和 `signal`。`generate()` 返回 Blob、实际 MIME、renderer ID、耗时、`embedded | provider-native | provider-dom | dom-fallback` 策略及 `degraded`；`generateBatch()` 逐项返回成功或失败且保持输入顺序，`generateStream()` 按完成顺序返回原始索引，并把待消费 Blob 数量限制在并发窗口内。
+
+失败会使用 `FileViewerThumbnailError`，稳定错误码包括 `browser-required`、`unsupported`、`timeout`、`aborted`、`capture-failed`、`capture-unavailable`、`tainted-canvas`、`empty-output`、`destroyed` 和 `invalid-options`。
+
+- 只支持真实浏览器；服务端需要自行在 Chromium 页面中调用。
+- 字符串形式的 `preset: 'all'` 只在 Vite 插件或 preset side-effect import 已完成注册时有效；跨 bundler 示例应直接传入上面导入的 preset 对象。
+- 内嵌预览始终优先于完整渲染：EPUB 使用声明的封面，OOXML 与 3MF 使用 package thumbnail relationship，OpenDocument 与 XMind 使用包内缩略图，Apple Numbers 存在 Quick Look 缩略图时直接复用。
+- 内嵌图片缺失、损坏、为空或浏览器无法解码时，会安全回退到 renderer 原生直出或首页捕获。
+- PDF 与图片使用原生直出；没有内嵌预览时，Office、OFD、电子书等使用 renderer 提供的首页目标。
+- 其他 renderer 使用 DOM fallback，并在结果中设置 `degraded: true`。
+- 不持久化源文件或缩略图；缓存与上传由调用方负责。

package/dist/capture.d.ts

@@ -0,0 +1,10 @@
+import type { ResolvedFileViewerThumbnailOptions } from './types.js';
+export interface ReusableFileViewerDomCaptureContext {
+    target?: Element;
+    key?: string;
+    context?: unknown;
+    destroy?: (context: unknown) => void;
+}
+export declare const destroyReusableFileViewerDomCaptureContext: (reusable?: ReusableFileViewerDomCaptureContext) => void;
+export declare const normalizeThumbnailBlob: (documentRef: Document, source: Blob, options: ResolvedFileViewerThumbnailOptions) => Promise<Blob>;
+export declare const captureThumbnailElement: (documentRef: Document, target: Element, options: ResolvedFileViewerThumbnailOptions, reusable?: ReusableFileViewerDomCaptureContext) => Promise<Blob>;

package/dist/capture.js

@@ -0,0 +1,222 @@
+import { FileViewerThumbnailError } from './types.js';
+export const destroyReusableFileViewerDomCaptureContext = (reusable) => {
+    var _a;
+    if (reusable === null || reusable === void 0 ? void 0 : reusable.context) {
+        (_a = reusable.destroy) === null || _a === void 0 ? void 0 : _a.call(reusable, reusable.context);
+    }
+    if (reusable) {
+        reusable.target = undefined;
+        reusable.key = undefined;
+        reusable.context = undefined;
+        reusable.destroy = undefined;
+    }
+};
+const HIDDEN_CAPTURE_CLASSES = new Set([
+    'file-viewer-toolbar',
+    'archive-preview-toolbar',
+    'pdf-toolbar',
+    'pdf-nav',
+    'epub-toolbar',
+    'epub-toc',
+    'sheet-loading',
+]);
+const mimeTypeForFormat = (format) => (format === 'png' ? 'image/png' : `image/${format}`);
+const canvasToBlob = (canvas, format, quality) => new Promise((resolve, reject) => {
+    try {
+        canvas.toBlob(blob => {
+            if (blob) {
+                const expectedMimeType = mimeTypeForFormat(format);
+                if (blob.type !== expectedMimeType) {
+                    reject(new FileViewerThumbnailError('capture-unavailable', `This browser cannot encode ${expectedMimeType} thumbnails.`));
+                }
+                else {
+                    resolve(blob);
+                }
+            }
+            else {
+                reject(new FileViewerThumbnailError('capture-failed', 'Canvas encoding returned no data.'));
+            }
+        }, mimeTypeForFormat(format), quality);
+    }
+    catch (error) {
+        reject(new FileViewerThumbnailError('tainted-canvas', 'Canvas pixels cannot be read.', error));
+    }
+});
+const loadBlobImage = async (documentRef, blob) => {
+    const view = documentRef.defaultView;
+    if (view === null || view === void 0 ? void 0 : view.createImageBitmap) {
+        try {
+            return await view.createImageBitmap(blob);
+        }
+        catch {
+            // Some browsers expose createImageBitmap but reject otherwise valid image
+            // formats. The image element decoder supports a wider set of inputs.
+        }
+    }
+    const url = URL.createObjectURL(blob);
+    try {
+        const image = documentRef.createElement('img');
+        await new Promise((resolve, reject) => {
+            image.onload = () => resolve();
+            image.onerror = () => reject(new FileViewerThumbnailError('capture-failed', 'Captured image could not be decoded.'));
+            image.src = url;
+        });
+        return image;
+    }
+    finally {
+        URL.revokeObjectURL(url);
+    }
+};
+const getImageSize = (image) => {
+    if ('naturalWidth' in image) {
+        return { width: image.naturalWidth, height: image.naturalHeight };
+    }
+    if ('videoWidth' in image) {
+        return { width: image.videoWidth, height: image.videoHeight };
+    }
+    return {
+        width: 'width' in image ? Number(image.width) : 0,
+        height: 'height' in image ? Number(image.height) : 0,
+    };
+};
+const closeImageSource = (image) => {
+    if ('close' in image && typeof image.close === 'function') {
+        image.close();
+    }
+};
+const assertCanvasNotBlank = (canvas, background) => {
+    const context = canvas.getContext('2d', { willReadFrequently: true });
+    if (!context) {
+        throw new FileViewerThumbnailError('capture-unavailable', 'A 2D canvas context is required.');
+    }
+    try {
+        const pixels = context.getImageData(0, 0, canvas.width, canvas.height).data;
+        const probe = canvas.ownerDocument.createElement('canvas').getContext('2d');
+        if (!probe) {
+            return;
+        }
+        probe.fillStyle = background;
+        probe.fillRect(0, 0, 1, 1);
+        const base = probe.getImageData(0, 0, 1, 1).data;
+        let differentPixels = 0;
+        for (let index = 0; index < pixels.length; index += 4) {
+            const distance = Math.abs(pixels[index] - base[0]) +
+                Math.abs(pixels[index + 1] - base[1]) +
+                Math.abs(pixels[index + 2] - base[2]);
+            if (pixels[index + 3] > 8 && distance > 24) {
+                differentPixels += 1;
+                if (differentPixels >= 8) {
+                    return;
+                }
+            }
+        }
+    }
+    catch (error) {
+        throw new FileViewerThumbnailError('tainted-canvas', 'Thumbnail pixels cannot be inspected.', error);
+    }
+    throw new FileViewerThumbnailError('empty-output', 'The renderer produced an empty thumbnail.');
+};
+export const normalizeThumbnailBlob = async (documentRef, source, options) => {
+    const image = await loadBlobImage(documentRef, source);
+    const sourceSize = getImageSize(image);
+    if (!sourceSize.width || !sourceSize.height) {
+        closeImageSource(image);
+        throw new FileViewerThumbnailError('empty-output', 'The captured image has no dimensions.');
+    }
+    const canvas = documentRef.createElement('canvas');
+    canvas.width = options.width;
+    canvas.height = options.height;
+    const context = canvas.getContext('2d');
+    if (!context) {
+        closeImageSource(image);
+        throw new FileViewerThumbnailError('capture-unavailable', 'A 2D canvas context is required.');
+    }
+    try {
+        context.fillStyle = options.background;
+        context.fillRect(0, 0, canvas.width, canvas.height);
+        const scale = options.fit === 'cover'
+            ? Math.max(options.width / sourceSize.width, options.height / sourceSize.height)
+            : Math.min(options.width / sourceSize.width, options.height / sourceSize.height);
+        const width = sourceSize.width * scale;
+        const height = sourceSize.height * scale;
+        context.drawImage(image, (options.width - width) / 2, (options.height - height) / 2, width, height);
+    }
+    finally {
+        closeImageSource(image);
+    }
+    assertCanvasNotBlank(canvas, options.background);
+    return canvasToBlob(canvas, options.format, options.quality);
+};
+const captureCanvas = (canvas) => new Promise((resolve, reject) => {
+    try {
+        canvas.toBlob(blob => blob
+            ? resolve(blob)
+            : reject(new FileViewerThumbnailError('capture-failed', 'Canvas capture returned no data.')), 'image/png');
+    }
+    catch (error) {
+        reject(new FileViewerThumbnailError('tainted-canvas', 'Canvas capture was blocked by cross-origin data.', error));
+    }
+});
+export const captureThumbnailElement = async (documentRef, target, options, reusable) => {
+    const view = documentRef.defaultView;
+    if (!view) {
+        throw new FileViewerThumbnailError('browser-required', 'Thumbnail capture requires a browser window.');
+    }
+    if (target instanceof view.HTMLIFrameElement) {
+        throw new FileViewerThumbnailError('capture-unavailable', 'Iframe content requires a renderer thumbnail adapter.');
+    }
+    if (target instanceof view.HTMLCanvasElement) {
+        return normalizeThumbnailBlob(documentRef, await captureCanvas(target), options);
+    }
+    try {
+        const { createContext, destroyContext, domToBlob } = await import('modern-screenshot');
+        const bounds = target.getBoundingClientRect();
+        if (!bounds.width || !bounds.height) {
+            throw new FileViewerThumbnailError('empty-output', 'The thumbnail target has no layout dimensions.');
+        }
+        const contextOptions = {
+            backgroundColor: options.background,
+            width: Math.ceil(bounds.width),
+            height: Math.ceil(bounds.height),
+            scale: 1,
+            filter(node) {
+                if (!(node instanceof view.HTMLElement)) {
+                    return true;
+                }
+                const role = node.getAttribute('role');
+                const isInteractive = ['BUTTON', 'INPUT', 'SELECT', 'TEXTAREA'].includes(node.tagName) ||
+                    node.tagName === 'NAV' || role === 'button' || role === 'toolbar' ||
+                    role === 'navigation' || role === 'progressbar';
+                return !isInteractive &&
+                    !node.hasAttribute('data-thumbnail-exclude') &&
+                    !Array.from(node.classList).some(className => HIDDEN_CAPTURE_CLASSES.has(className)) &&
+                    node.getAttribute('aria-busy') !== 'true';
+            },
+        };
+        const contextKey = `${contextOptions.width}:${contextOptions.height}:${options.background}`;
+        if (reusable && (reusable.target !== target || reusable.key !== contextKey)) {
+            destroyReusableFileViewerDomCaptureContext(reusable);
+        }
+        if (reusable && !reusable.context) {
+            reusable.target = target;
+            reusable.key = contextKey;
+            reusable.context = await createContext(target, { ...contextOptions, autoDestruct: false });
+            reusable.destroy = context => destroyContext(context);
+        }
+        const blob = (reusable === null || reusable === void 0 ? void 0 : reusable.context)
+            ? await domToBlob(reusable.context)
+            : await domToBlob(target, contextOptions);
+        if (!blob) {
+            throw new FileViewerThumbnailError('capture-failed', 'DOM capture returned no data.');
+        }
+        return normalizeThumbnailBlob(documentRef, blob, options);
+    }
+    catch (error) {
+        if (error instanceof FileViewerThumbnailError) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        const code = /security|taint|cross.origin/i.test(message) ? 'tainted-canvas' : 'capture-failed';
+        throw new FileViewerThumbnailError(code, `Unable to capture renderer output: ${message}`, error);
+    }
+};

package/dist/embedded/epub.d.ts

@@ -0,0 +1,2 @@
+import type { NormalizedFileViewerSource } from '@file-viewer/core';
+export declare const extractEpubCover: (source: NormalizedFileViewerSource, signal?: AbortSignal) => Promise<Blob | null>;

package/dist/embedded/epub.js

@@ -0,0 +1,43 @@
+import { MAX_EMBEDDED_THUMBNAIL_BYTES, raceWithAbort, throwIfAborted, } from './shared.js';
+const resolveEpubFactory = (module) => {
+    let value = module;
+    for (let depth = 0; depth < 3 && value && typeof value !== 'function'; depth += 1) {
+        value = value.default;
+    }
+    if (typeof value !== 'function') {
+        throw new Error('epubjs module does not expose a callable factory.');
+    }
+    return value;
+};
+export const extractEpubCover = async (source, signal) => {
+    var _a;
+    if (!source.buffer) {
+        return null;
+    }
+    throwIfAborted(signal);
+    const ePub = resolveEpubFactory(await import('epubjs'));
+    const book = ePub(source.buffer.slice(0), { openAs: 'binary', replacements: 'blobUrl' });
+    let destroyed = false;
+    const destroyBook = () => {
+        if (!destroyed) {
+            destroyed = true;
+            book.destroy();
+        }
+    };
+    try {
+        await raceWithAbort(book.ready, signal, destroyBook);
+        const coverUrl = await raceWithAbort(((_a = book.coverUrl) === null || _a === void 0 ? void 0 : _a.call(book)) || Promise.resolve(null), signal, destroyBook);
+        if (!coverUrl) {
+            return null;
+        }
+        const response = await fetch(coverUrl, { signal });
+        if (!response.ok) {
+            return null;
+        }
+        const blob = await response.blob();
+        return blob.size && blob.size <= MAX_EMBEDDED_THUMBNAIL_BYTES ? blob : null;
+    }
+    finally {
+        destroyBook();
+    }
+};

package/dist/embedded/index.d.ts

@@ -0,0 +1,3 @@
+import type { NormalizedFileViewerSource } from '@file-viewer/core';
+export declare const canExtractEmbeddedThumbnail: (extension: string) => boolean;
+export declare const extractEmbeddedThumbnail: (source: NormalizedFileViewerSource, documentRef: Document, signal?: AbortSignal) => Promise<Blob | null>;

package/dist/embedded/index.js

@@ -0,0 +1,9 @@
+import { extractEpubCover } from './epub.js';
+import { canExtractZipPackageThumbnail, extractZipPackageThumbnail, } from './package.js';
+export const canExtractEmbeddedThumbnail = (extension) => (extension === 'epub' || canExtractZipPackageThumbnail(extension));
+export const extractEmbeddedThumbnail = async (source, documentRef, signal) => {
+    if (source.extension === 'epub') {
+        return extractEpubCover(source, signal);
+    }
+    return extractZipPackageThumbnail(source, documentRef, signal);
+};

package/dist/embedded/package.d.ts

@@ -0,0 +1,3 @@
+import type { NormalizedFileViewerSource } from '@file-viewer/core';
+export declare const canExtractZipPackageThumbnail: (extension: string) => boolean;
+export declare const extractZipPackageThumbnail: (source: NormalizedFileViewerSource, documentRef: Document, signal?: AbortSignal) => Promise<Blob | null>;

package/dist/embedded/package.js

@@ -0,0 +1,145 @@
+import { MAX_EMBEDDED_THUMBNAIL_BYTES, raceWithAbort, throwIfAborted, toImageBlob, } from './shared.js';
+const OPEN_XML_EXTENSIONS = new Set([
+    'docx', 'docm', 'dotx', 'dotm',
+    'pptx', 'pptm', 'potx', 'potm', 'ppsx', 'ppsm',
+    'xlsx', 'xltx', 'xlsm', 'xltm', 'xlsb',
+]);
+const OPEN_DOCUMENT_EXTENSIONS = new Set(['odt', 'odp', 'ods']);
+const OPEN_XML_MAIN_PARTS = {
+    docx: 'word/document.xml', docm: 'word/document.xml',
+    dotx: 'word/document.xml', dotm: 'word/document.xml',
+    pptx: 'ppt/presentation.xml', pptm: 'ppt/presentation.xml',
+    potx: 'ppt/presentation.xml', potm: 'ppt/presentation.xml',
+    ppsx: 'ppt/presentation.xml', ppsm: 'ppt/presentation.xml',
+    xlsx: 'xl/workbook.xml', xltx: 'xl/workbook.xml',
+    xlsm: 'xl/workbook.xml', xltm: 'xl/workbook.xml',
+    xlsb: 'xl/workbook.bin',
+};
+const normalizeZipPath = (path) => {
+    let decoded = path.trim().replace(/\\/g, '/').split(/[?#]/, 1)[0] || '';
+    try {
+        decoded = decodeURIComponent(decoded);
+    }
+    catch {
+        // Keep the original package path when it contains malformed escapes.
+    }
+    try {
+        return new URL(decoded, 'https://file-viewer.invalid/').pathname.replace(/^\/+/, '');
+    }
+    catch {
+        return decoded.replace(/^\/+/, '');
+    }
+};
+const findZipEntry = (zip, path) => {
+    const normalized = normalizeZipPath(path);
+    const exact = zip.file(normalized);
+    if (exact && !exact.dir) {
+        return exact;
+    }
+    const lower = normalized.toLowerCase();
+    return Object.values(zip.files).find(entry => !entry.dir && entry.name.toLowerCase() === lower) || null;
+};
+const readZipImage = async (zip, paths, signal) => {
+    var _a;
+    for (const path of paths) {
+        throwIfAborted(signal);
+        const entry = findZipEntry(zip, path);
+        if (!entry) {
+            continue;
+        }
+        const declaredSize = Number((_a = entry._data) === null || _a === void 0 ? void 0 : _a.uncompressedSize);
+        if (Number.isFinite(declaredSize) && declaredSize > MAX_EMBEDDED_THUMBNAIL_BYTES) {
+            continue;
+        }
+        const blob = toImageBlob(await raceWithAbort(entry.async('uint8array'), signal), entry.name);
+        if (blob) {
+            return blob;
+        }
+    }
+    return null;
+};
+const readPackageRelationshipTarget = async (zip, documentRef, typePattern, signal) => {
+    var _a;
+    const relationshipEntry = findZipEntry(zip, '_rels/.rels');
+    if (!relationshipEntry) {
+        return '';
+    }
+    const bytes = await raceWithAbort(relationshipEntry.async('uint8array'), signal);
+    const Parser = ((_a = documentRef.defaultView) === null || _a === void 0 ? void 0 : _a.DOMParser) || globalThis.DOMParser;
+    if (!Parser) {
+        return '';
+    }
+    const relationshipDocument = new Parser().parseFromString(new TextDecoder().decode(bytes), 'application/xml');
+    const relationships = Array.from(relationshipDocument.getElementsByTagName('*'))
+        .filter(element => (element.localName || element.tagName).toLowerCase() === 'relationship');
+    for (const relationship of relationships) {
+        const type = relationship.getAttribute('Type') || '';
+        const targetMode = relationship.getAttribute('TargetMode') || '';
+        if (typePattern.test(type) && !/^external$/i.test(targetMode)) {
+            return normalizeZipPath(relationship.getAttribute('Target') || '');
+        }
+    }
+    return '';
+};
+const extractOpenXmlThumbnail = async (zip, extension, documentRef, signal) => {
+    const mainPart = OPEN_XML_MAIN_PARTS[extension];
+    if (!findZipEntry(zip, '[Content_Types].xml') || !mainPart || !findZipEntry(zip, mainPart)) {
+        return null;
+    }
+    const relationshipTarget = await readPackageRelationshipTarget(zip, documentRef, /\/metadata\/thumbnail$/i, signal);
+    return readZipImage(zip, [
+        relationshipTarget,
+        'docProps/thumbnail.jpeg', 'docProps/thumbnail.jpg',
+        'docProps/thumbnail.png', 'docProps/thumbnail.webp',
+    ].filter(Boolean), signal);
+};
+const extractThreeMfThumbnail = async (zip, documentRef, signal) => {
+    const hasModel = Object.values(zip.files).some(entry => !entry.dir && /^3d\/.*\.model$/i.test(entry.name));
+    if (!findZipEntry(zip, '[Content_Types].xml') || !hasModel) {
+        return null;
+    }
+    const relationshipTarget = await readPackageRelationshipTarget(zip, documentRef, /\/thumbnail$/i, signal);
+    return readZipImage(zip, [
+        relationshipTarget,
+        'Metadata/thumbnail.png', 'Metadata/thumbnail.jpg', 'Metadata/thumbnail.jpeg',
+    ].filter(Boolean), signal);
+};
+export const canExtractZipPackageThumbnail = (extension) => (extension === 'xmind' || extension === 'numbers' || extension === '3mf' ||
+    OPEN_XML_EXTENSIONS.has(extension) || OPEN_DOCUMENT_EXTENSIONS.has(extension));
+export const extractZipPackageThumbnail = async (source, documentRef, signal) => {
+    if (!source.buffer || !canExtractZipPackageThumbnail(source.extension)) {
+        return null;
+    }
+    throwIfAborted(signal);
+    const module = await import('jszip');
+    const JSZip = (module.default || module);
+    const zip = await raceWithAbort(JSZip.loadAsync(source.buffer), signal);
+    throwIfAborted(signal);
+    if (OPEN_XML_EXTENSIONS.has(source.extension)) {
+        return extractOpenXmlThumbnail(zip, source.extension, documentRef, signal);
+    }
+    if (OPEN_DOCUMENT_EXTENSIONS.has(source.extension)) {
+        if (!findZipEntry(zip, 'mimetype') || !findZipEntry(zip, 'content.xml'))
+            return null;
+        return readZipImage(zip, [
+            'Thumbnails/thumbnail.png', 'Thumbnails/thumbnail.jpg',
+            'Thumbnails/thumbnail.jpeg', 'Thumbnails/thumbnail.webp',
+        ], signal);
+    }
+    if (source.extension === 'xmind') {
+        if (!findZipEntry(zip, 'content.json') && !findZipEntry(zip, 'content.xml'))
+            return null;
+        return readZipImage(zip, [
+            'Thumbnails/thumbnail.png', 'Thumbnails/thumbnail.jpg',
+            'Thumbnails/thumbnail.jpeg', 'preview.png', 'thumbnail.png',
+        ], signal);
+    }
+    if (source.extension === 'numbers') {
+        if (!findZipEntry(zip, 'Index/Document.iwa') && !findZipEntry(zip, 'index.xml'))
+            return null;
+        return readZipImage(zip, [
+            'QuickLook/Thumbnail.jpg', 'QuickLook/Thumbnail.jpeg', 'QuickLook/Thumbnail.png',
+        ], signal);
+    }
+    return extractThreeMfThumbnail(zip, documentRef, signal);
+};

package/dist/embedded/shared.d.ts

@@ -0,0 +1,4 @@
+export declare const MAX_EMBEDDED_THUMBNAIL_BYTES: number;
+export declare const throwIfAborted: (signal?: AbortSignal) => void;
+export declare const raceWithAbort: <T>(operation: Promise<T>, signal?: AbortSignal, onAbort?: () => void) => Promise<T>;
+export declare const toImageBlob: (bytes: Uint8Array, path: string) => Blob | null;

package/dist/embedded/shared.js

@@ -0,0 +1,69 @@
+export const MAX_EMBEDDED_THUMBNAIL_BYTES = 20 * 1024 * 1024;
+const copyToArrayBuffer = (bytes) => {
+    const copy = new Uint8Array(bytes.byteLength);
+    copy.set(bytes);
+    return copy.buffer;
+};
+const abortError = (signal) => (signal.reason instanceof Error
+    ? signal.reason
+    : new DOMException('Thumbnail extraction was aborted.', 'AbortError'));
+export const throwIfAborted = (signal) => {
+    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+        throw abortError(signal);
+    }
+};
+export const raceWithAbort = (operation, signal, onAbort) => {
+    if (!signal) {
+        return operation;
+    }
+    throwIfAborted(signal);
+    return new Promise((resolve, reject) => {
+        const abort = () => {
+            onAbort === null || onAbort === void 0 ? void 0 : onAbort();
+            reject(abortError(signal));
+        };
+        signal.addEventListener('abort', abort, { once: true });
+        operation.then(value => {
+            signal.removeEventListener('abort', abort);
+            resolve(value);
+        }, error => {
+            signal.removeEventListener('abort', abort);
+            reject(error);
+        });
+    });
+};
+const mimeTypeFromBytes = (bytes, path) => {
+    var _a, _b;
+    if (bytes[0] === 0xff && bytes[1] === 0xd8 && bytes[2] === 0xff)
+        return 'image/jpeg';
+    if (bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4e && bytes[3] === 0x47)
+        return 'image/png';
+    if (bytes[0] === 0x47 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x38)
+        return 'image/gif';
+    if (bytes[0] === 0x52 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x46 &&
+        bytes[8] === 0x57 && bytes[9] === 0x45 && bytes[10] === 0x42 && bytes[11] === 0x50)
+        return 'image/webp';
+    if (bytes[0] === 0x42 && bytes[1] === 0x4d)
+        return 'image/bmp';
+    const extension = (_b = (_a = path.split(/[?#]/, 1)[0]) === null || _a === void 0 ? void 0 : _a.split('.').pop()) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+    if (extension === 'jpg' || extension === 'jpeg')
+        return 'image/jpeg';
+    if (extension === 'png')
+        return 'image/png';
+    if (extension === 'gif')
+        return 'image/gif';
+    if (extension === 'webp')
+        return 'image/webp';
+    if (extension === 'bmp')
+        return 'image/bmp';
+    if (extension === 'svg' || extension === 'svgz')
+        return 'image/svg+xml';
+    return '';
+};
+export const toImageBlob = (bytes, path) => {
+    if (!bytes.byteLength || bytes.byteLength > MAX_EMBEDDED_THUMBNAIL_BYTES) {
+        return null;
+    }
+    const type = mimeTypeFromBytes(bytes, path);
+    return type ? new Blob([copyToArrayBuffer(bytes)], { type }) : null;
+};

package/dist/generator.d.ts

@@ -0,0 +1,2 @@
+import { type CreateFileViewerThumbnailGeneratorOptions, type FileViewerThumbnailGenerator } from './types.js';
+export declare const createFileViewerThumbnailGenerator: (createOptions?: CreateFileViewerThumbnailGeneratorOptions) => FileViewerThumbnailGenerator;

package/dist/generator.js

@@ -0,0 +1,360 @@
+import { createViewer, normalizeSource, readFileViewerBuffer, } from '@file-viewer/core';
+import { captureThumbnailElement, destroyReusableFileViewerDomCaptureContext, normalizeThumbnailBlob, } from './capture.js';
+import { canExtractEmbeddedThumbnail, extractEmbeddedThumbnail } from './embedded/index.js';
+import { resolveFileViewerThumbnailConcurrency, resolveFileViewerThumbnailOptions, toCaptureOptions, } from './options.js';
+import { FileViewerThumbnailError, } from './types.js';
+const toThumbnailError = (error) => {
+    if (error instanceof FileViewerThumbnailError) {
+        return error;
+    }
+    if (error instanceof DOMException && error.name === 'AbortError') {
+        return new FileViewerThumbnailError('aborted', 'Thumbnail generation was aborted.', error);
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    return new FileViewerThumbnailError('capture-failed', message, error);
+};
+const throwIfAborted = (signal) => {
+    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+        throw new FileViewerThumbnailError('aborted', 'Thumbnail generation was aborted.', signal.reason);
+    }
+};
+const withDeadline = async (operation, timeoutMs, signal, onTimeout) => new Promise((resolve, reject) => {
+    throwIfAborted(signal);
+    let settled = false;
+    const finish = (callback) => {
+        if (settled) {
+            return;
+        }
+        settled = true;
+        clearTimeout(timer);
+        signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onAbort);
+        callback();
+    };
+    const timer = setTimeout(() => finish(() => {
+        const error = new FileViewerThumbnailError('timeout', `Thumbnail generation exceeded ${timeoutMs}ms.`);
+        onTimeout === null || onTimeout === void 0 ? void 0 : onTimeout(error);
+        reject(error);
+    }), timeoutMs);
+    const onAbort = () => finish(() => reject((signal === null || signal === void 0 ? void 0 : signal.reason) instanceof FileViewerThumbnailError
+        ? signal.reason
+        : new FileViewerThumbnailError('aborted', 'Thumbnail generation was aborted.', signal === null || signal === void 0 ? void 0 : signal.reason)));
+    signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', onAbort, { once: true });
+    operation.then(value => finish(() => resolve(value)), error => finish(() => reject(error)));
+});
+const waitForCaptureReadiness = async (documentRef, signal) => {
+    var _a;
+    throwIfAborted(signal);
+    await ((_a = documentRef.fonts) === null || _a === void 0 ? void 0 : _a.ready.catch(() => undefined));
+    const view = documentRef.defaultView;
+    await new Promise(resolve => {
+        var _a;
+        if (!(view === null || view === void 0 ? void 0 : view.requestAnimationFrame)) {
+            (_a = view === null || view === void 0 ? void 0 : view.setTimeout(() => resolve(), 0)) !== null && _a !== void 0 ? _a : resolve();
+            return;
+        }
+        view.requestAnimationFrame(() => view.requestAnimationFrame(() => resolve()));
+    });
+    throwIfAborted(signal);
+};
+const createPoolSlot = (documentRef, options) => {
+    const host = documentRef.createElement('div');
+    host.dataset.fileViewerThumbnailSlot = '';
+    host.style.cssText = [
+        'position:fixed',
+        'left:-100000px',
+        'top:0',
+        'width:320px',
+        'height:240px',
+        'overflow:hidden',
+        'pointer-events:none',
+        'contain:layout style paint',
+        'z-index:-2147483648',
+    ].join(';');
+    documentRef.body.append(host);
+    const viewer = createViewer(host, {
+        options: {
+            ...options.viewerOptions,
+            toolbar: false,
+            watermark: false,
+            fit: 'contain',
+        },
+        renderPurpose: 'thumbnail',
+    });
+    return { host, viewer, captureContext: {} };
+};
+const materializeThumbnailSource = async (source, signal) => {
+    var _a;
+    if (source.buffer) {
+        return source;
+    }
+    if (source.file) {
+        return { ...source, buffer: await readFileViewerBuffer(source.file) };
+    }
+    if (source.url) {
+        const response = await fetch(source.url, { signal });
+        if (!response.ok) {
+            throw new FileViewerThumbnailError('capture-failed', `Unable to download thumbnail source: HTTP ${response.status}.`);
+        }
+        return {
+            ...source,
+            buffer: await response.arrayBuffer(),
+            size: (_a = source.size) !== null && _a !== void 0 ? _a : (Number(response.headers.get('content-length')) || undefined),
+        };
+    }
+    throw new FileViewerThumbnailError('unsupported', 'Thumbnail source has no file bytes or URL.');
+};
+const generateInSlot = async (slot, source, options, generatorSignal) => {
+    var _a, _b, _c, _d, _e, _f;
+    const startedAt = performance.now();
+    const remainingTime = () => Math.max(1, options.timeoutMs - (performance.now() - startedAt));
+    const taskController = new AbortController();
+    const sourceSignals = [options.signal, generatorSignal].filter((signal) => Boolean(signal));
+    const abortListeners = [];
+    for (const signal of sourceSignals) {
+        if (signal.aborted) {
+            taskController.abort(signal.reason);
+            break;
+        }
+        const onAbort = () => taskController.abort(signal.reason);
+        signal.addEventListener('abort', onAbort, { once: true });
+        abortListeners.push(() => signal.removeEventListener('abort', onAbort));
+    }
+    const taskOptions = { ...options, signal: taskController.signal };
+    const runWithDeadline = (operation) => withDeadline(operation, remainingTime(), taskController.signal, error => taskController.abort(error));
+    slot.host.style.width = `${options.width}px`;
+    slot.host.style.height = `${options.height}px`;
+    throwIfAborted(taskOptions.signal);
+    try {
+        const materializedSource = await runWithDeadline(materializeThumbnailSource(source, taskOptions.signal));
+        const normalizedMaterializedSource = normalizeSource(materializedSource);
+        await runWithDeadline(((_b = (_a = slot.viewer).prepare) === null || _b === void 0 ? void 0 : _b.call(_a)) || Promise.resolve());
+        const preparedRenderer = slot.viewer.getRenderer(normalizedMaterializedSource.extension);
+        if (!(preparedRenderer === null || preparedRenderer === void 0 ? void 0 : preparedRenderer.load)) {
+            throw new FileViewerThumbnailError('unsupported', `No installed renderer can generate a .${normalizedMaterializedSource.extension || source.type || ''} thumbnail.`);
+        }
+        const captureOptions = toCaptureOptions(taskOptions);
+        if (canExtractEmbeddedThumbnail(normalizedMaterializedSource.extension)) {
+            try {
+                const embedded = await runWithDeadline(extractEmbeddedThumbnail(normalizedMaterializedSource, slot.host.ownerDocument, taskOptions.signal));
+                if (embedded) {
+                    const blob = await runWithDeadline(normalizeThumbnailBlob(slot.host.ownerDocument, embedded, taskOptions));
+                    return {
+                        blob,
+                        width: options.width,
+                        height: options.height,
+                        mimeType: blob.type,
+                        filename: normalizedMaterializedSource.filename,
+                        extension: normalizedMaterializedSource.extension,
+                        rendererId: preparedRenderer.id,
+                        strategy: 'embedded',
+                        degraded: false,
+                        durationMs: Math.max(0, performance.now() - startedAt),
+                    };
+                }
+            }
+            catch (error) {
+                if (error instanceof FileViewerThumbnailError &&
+                    (error.code === 'timeout' || error.code === 'aborted')) {
+                    throw error;
+                }
+                if (taskOptions.signal.aborted) {
+                    const reason = taskOptions.signal.reason;
+                    if (reason instanceof FileViewerThumbnailError) {
+                        throw reason;
+                    }
+                    throw new FileViewerThumbnailError('aborted', 'Thumbnail generation was aborted.', reason);
+                }
+                // Missing, corrupt, or browser-incompatible embedded images are hints,
+                // not fatal document errors. Continue through the renderer fast path.
+            }
+        }
+        const session = await runWithDeadline(slot.viewer.load(materializedSource, { signal: taskOptions.signal }));
+        const normalizedSource = slot.viewer.getSource();
+        const renderer = slot.viewer.getRenderer();
+        if (!session || !normalizedSource || !(renderer === null || renderer === void 0 ? void 0 : renderer.load)) {
+            throw new FileViewerThumbnailError('unsupported', `No installed renderer can generate a .${(normalizedSource === null || normalizedSource === void 0 ? void 0 : normalizedSource.extension) || source.type || ''} thumbnail.`);
+        }
+        await runWithDeadline(waitForCaptureReadiness(slot.host.ownerDocument, taskOptions.signal));
+        const adapter = ((_d = (_c = slot.viewer).getThumbnailAdapter) === null || _d === void 0 ? void 0 : _d.call(_c)) || null;
+        const captured = await runWithDeadline((async () => {
+            var _a, _b, _c;
+            await ((_a = adapter === null || adapter === void 0 ? void 0 : adapter.beforeCapture) === null || _a === void 0 ? void 0 : _a.call(adapter, captureOptions));
+            throwIfAborted(taskOptions.signal);
+            let blob = await ((_b = adapter === null || adapter === void 0 ? void 0 : adapter.capture) === null || _b === void 0 ? void 0 : _b.call(adapter, captureOptions)) || null;
+            let strategy = (adapter === null || adapter === void 0 ? void 0 : adapter.captureSource) === 'embedded'
+                ? 'embedded'
+                : 'provider-native';
+            if (blob) {
+                blob = await normalizeThumbnailBlob(slot.host.ownerDocument, blob, taskOptions);
+            }
+            else {
+                const adapterTarget = await ((_c = adapter === null || adapter === void 0 ? void 0 : adapter.getTarget) === null || _c === void 0 ? void 0 : _c.call(adapter, captureOptions)) || null;
+                strategy = adapterTarget ? 'provider-dom' : 'dom-fallback';
+                blob = await captureThumbnailElement(slot.host.ownerDocument, adapterTarget || slot.host, taskOptions, slot.captureContext);
+            }
+            return { blob, strategy };
+        })());
+        const { blob, strategy } = captured;
+        return {
+            blob,
+            width: options.width,
+            height: options.height,
+            mimeType: blob.type,
+            filename: normalizedSource.filename,
+            extension: normalizedSource.extension,
+            rendererId: renderer.id,
+            strategy,
+            degraded: strategy === 'dom-fallback',
+            durationMs: Math.max(0, performance.now() - startedAt),
+        };
+    }
+    catch (error) {
+        throw toThumbnailError(error);
+    }
+    finally {
+        abortListeners.forEach(remove => remove());
+        taskController.abort();
+        const unloading = (_f = (_e = slot.viewer).unload) === null || _f === void 0 ? void 0 : _f.call(_e, 'replace');
+        await (unloading === null || unloading === void 0 ? void 0 : unloading.catch(() => undefined));
+    }
+};
+export const createFileViewerThumbnailGenerator = (createOptions = {}) => {
+    var _a;
+    const documentRef = createOptions.document || (typeof document !== 'undefined' ? document : undefined);
+    if (!(documentRef === null || documentRef === void 0 ? void 0 : documentRef.body) || !documentRef.defaultView) {
+        throw new FileViewerThumbnailError('browser-required', 'Thumbnail generation requires a browser document.');
+    }
+    const concurrency = resolveFileViewerThumbnailConcurrency(createOptions.concurrency);
+    const defaultTimeoutMs = (_a = createOptions.timeoutMs) !== null && _a !== void 0 ? _a : 30000;
+    const slots = Array.from({ length: concurrency }, () => createPoolSlot(documentRef, createOptions));
+    const availableSlots = [...slots];
+    const jobs = [];
+    const active = new Set();
+    const destroyController = new AbortController();
+    let destroyed = false;
+    const drain = () => {
+        var _a, _b;
+        while (!destroyed && availableSlots.length && jobs.length) {
+            const slot = availableSlots.shift();
+            const job = jobs.shift();
+            (_a = job.removeAbort) === null || _a === void 0 ? void 0 : _a.call(job);
+            if ((_b = job.signal) === null || _b === void 0 ? void 0 : _b.aborted) {
+                availableSlots.push(slot);
+                job.reject(new FileViewerThumbnailError('aborted', 'Thumbnail generation was aborted.', job.signal.reason));
+                continue;
+            }
+            const task = job.run(slot);
+            active.add(task);
+            void task.then(job.resolve, job.reject).finally(() => {
+                active.delete(task);
+                availableSlots.push(slot);
+                drain();
+            });
+        }
+    };
+    const enqueue = (job) => new Promise((resolve, reject) => {
+        var _a;
+        if (destroyed) {
+            reject(new FileViewerThumbnailError('destroyed', 'The thumbnail generator has been destroyed.'));
+            return;
+        }
+        if ((_a = job.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
+            reject(new FileViewerThumbnailError('aborted', 'Thumbnail generation was aborted.', job.signal.reason));
+            return;
+        }
+        const queued = { ...job, resolve, reject };
+        if (job.signal) {
+            const onAbort = () => {
+                var _a;
+                const index = jobs.indexOf(queued);
+                if (index >= 0) {
+                    jobs.splice(index, 1);
+                    reject(new FileViewerThumbnailError('aborted', 'Thumbnail generation was aborted.', (_a = job.signal) === null || _a === void 0 ? void 0 : _a.reason));
+                }
+            };
+            job.signal.addEventListener('abort', onAbort, { once: true });
+            queued.removeAbort = () => { var _a; return (_a = job.signal) === null || _a === void 0 ? void 0 : _a.removeEventListener('abort', onAbort); };
+        }
+        jobs.push(queued);
+        drain();
+    });
+    const generate = async (source, options) => {
+        const resolved = resolveFileViewerThumbnailOptions(options, defaultTimeoutMs);
+        return enqueue({
+            signal: resolved.signal,
+            run: slot => generateInSlot(slot, source, resolved, destroyController.signal),
+        });
+    };
+    const toBatchItem = async (source, index, options) => {
+        try {
+            return { ok: true, index, source, result: await generate(source, options) };
+        }
+        catch (error) {
+            return { ok: false, index, source, error: toThumbnailError(error) };
+        }
+    };
+    return {
+        generate,
+        generateBatch(sources, options) {
+            return Promise.all(sources.map((source, index) => toBatchItem(source, index, options)));
+        },
+        async *generateStream(sources, options) {
+            var _a, _b, _c;
+            const streamController = new AbortController();
+            const onSourceAbort = () => { var _a; return streamController.abort((_a = options === null || options === void 0 ? void 0 : options.signal) === null || _a === void 0 ? void 0 : _a.reason); };
+            if ((_a = options === null || options === void 0 ? void 0 : options.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
+                streamController.abort(options.signal.reason);
+            }
+            else {
+                (_b = options === null || options === void 0 ? void 0 : options.signal) === null || _b === void 0 ? void 0 : _b.addEventListener('abort', onSourceAbort, { once: true });
+            }
+            const streamOptions = { ...options, signal: streamController.signal };
+            const pending = [];
+            let nextIndex = 0;
+            const fillWindow = () => {
+                while (nextIndex < sources.length && pending.length < concurrency) {
+                    const index = nextIndex++;
+                    pending.push({ index, promise: toBatchItem(sources[index], index, streamOptions) });
+                }
+            };
+            try {
+                fillWindow();
+                while (pending.length) {
+                    const completed = await Promise.race(pending.map(item => item.promise.then(value => ({ index: item.index, value }))));
+                    const pendingIndex = pending.findIndex(item => item.index === completed.index);
+                    if (pendingIndex >= 0) {
+                        pending.splice(pendingIndex, 1);
+                    }
+                    // Keep at most one concurrency window resident so a slow stream
+                    // consumer cannot accumulate a Blob for every source in memory.
+                    fillWindow();
+                    yield completed.value;
+                }
+            }
+            finally {
+                (_c = options === null || options === void 0 ? void 0 : options.signal) === null || _c === void 0 ? void 0 : _c.removeEventListener('abort', onSourceAbort);
+                streamController.abort('Thumbnail stream closed.');
+            }
+        },
+        async destroy() {
+            if (destroyed) {
+                return;
+            }
+            destroyed = true;
+            const destroyedError = new FileViewerThumbnailError('destroyed', 'The thumbnail generator has been destroyed.');
+            destroyController.abort(destroyedError);
+            jobs.splice(0).forEach(job => {
+                var _a;
+                (_a = job.removeAbort) === null || _a === void 0 ? void 0 : _a.call(job);
+                job.reject(destroyedError);
+            });
+            await Promise.allSettled([...active]);
+            await Promise.all(slots.map(slot => slot.viewer.destroy('component-unmount')));
+            slots.forEach(slot => {
+                destroyReusableFileViewerDomCaptureContext(slot.captureContext);
+                slot.host.remove();
+            });
+            availableSlots.length = 0;
+        },
+    };
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { DEFAULT_FILE_VIEWER_THUMBNAIL_OPTIONS, resolveFileViewerThumbnailConcurrency, resolveFileViewerThumbnailOptions, } from './options.js';
+export { createFileViewerThumbnailGenerator } from './generator.js';
+export { FileViewerThumbnailError, type CreateFileViewerThumbnailGeneratorOptions, type FileViewerThumbnailBatchFailure, type FileViewerThumbnailBatchItem, type FileViewerThumbnailBatchSuccess, type FileViewerThumbnailErrorCode, type FileViewerThumbnailGenerator, type FileViewerThumbnailOptions, type FileViewerThumbnailResult, type FileViewerThumbnailStrategy, type ResolvedFileViewerThumbnailOptions, } from './types.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { DEFAULT_FILE_VIEWER_THUMBNAIL_OPTIONS, resolveFileViewerThumbnailConcurrency, resolveFileViewerThumbnailOptions, } from './options.js';
+export { createFileViewerThumbnailGenerator } from './generator.js';
+export { FileViewerThumbnailError, } from './types.js';

package/dist/options.d.ts

@@ -0,0 +1,14 @@
+import type { FileViewerThumbnailCaptureOptions } from '@file-viewer/core';
+import { type FileViewerThumbnailOptions, type ResolvedFileViewerThumbnailOptions } from './types.js';
+export declare const DEFAULT_FILE_VIEWER_THUMBNAIL_OPTIONS: Readonly<{
+    readonly width: 320;
+    readonly height: 240;
+    readonly format: "webp";
+    readonly quality: 0.8;
+    readonly fit: "contain";
+    readonly background: "#f1f5f9";
+    readonly timeoutMs: 30000;
+}>;
+export declare const resolveFileViewerThumbnailOptions: (options?: FileViewerThumbnailOptions, defaultTimeoutMs?: number) => ResolvedFileViewerThumbnailOptions;
+export declare const toCaptureOptions: (options: ResolvedFileViewerThumbnailOptions) => FileViewerThumbnailCaptureOptions;
+export declare const resolveFileViewerThumbnailConcurrency: (value?: number) => number;

package/dist/options.js

@@ -0,0 +1,61 @@
+import { FileViewerThumbnailError, } from './types.js';
+export const DEFAULT_FILE_VIEWER_THUMBNAIL_OPTIONS = Object.freeze({
+    width: 320,
+    height: 240,
+    format: 'webp',
+    quality: 0.8,
+    fit: 'contain',
+    background: '#f1f5f9',
+    timeoutMs: 30000,
+});
+const resolveInteger = (value, fallback, label) => {
+    const resolved = value !== null && value !== void 0 ? value : fallback;
+    if (!Number.isFinite(resolved) || resolved < 1 || resolved > 8192) {
+        throw new FileViewerThumbnailError('invalid-options', `${label} must be between 1 and 8192.`);
+    }
+    return Math.round(resolved);
+};
+export const resolveFileViewerThumbnailOptions = (options = {}, defaultTimeoutMs = DEFAULT_FILE_VIEWER_THUMBNAIL_OPTIONS.timeoutMs) => {
+    var _a, _b;
+    const format = options.format || DEFAULT_FILE_VIEWER_THUMBNAIL_OPTIONS.format;
+    const fit = options.fit || DEFAULT_FILE_VIEWER_THUMBNAIL_OPTIONS.fit;
+    const quality = (_a = options.quality) !== null && _a !== void 0 ? _a : DEFAULT_FILE_VIEWER_THUMBNAIL_OPTIONS.quality;
+    const timeoutMs = (_b = options.timeoutMs) !== null && _b !== void 0 ? _b : defaultTimeoutMs;
+    if (!['webp', 'jpeg', 'png'].includes(format)) {
+        throw new FileViewerThumbnailError('invalid-options', `Unsupported thumbnail format: ${format}`);
+    }
+    if (fit !== 'contain' && fit !== 'cover') {
+        throw new FileViewerThumbnailError('invalid-options', `Unsupported thumbnail fit: ${fit}`);
+    }
+    if (!Number.isFinite(quality) || quality < 0 || quality > 1) {
+        throw new FileViewerThumbnailError('invalid-options', 'quality must be between 0 and 1.');
+    }
+    if (!Number.isFinite(timeoutMs) || timeoutMs < 1) {
+        throw new FileViewerThumbnailError('invalid-options', 'timeoutMs must be greater than 0.');
+    }
+    return {
+        width: resolveInteger(options.width, DEFAULT_FILE_VIEWER_THUMBNAIL_OPTIONS.width, 'width'),
+        height: resolveInteger(options.height, DEFAULT_FILE_VIEWER_THUMBNAIL_OPTIONS.height, 'height'),
+        format,
+        quality,
+        fit,
+        background: options.background || DEFAULT_FILE_VIEWER_THUMBNAIL_OPTIONS.background,
+        timeoutMs,
+        signal: options.signal,
+    };
+};
+export const toCaptureOptions = (options) => ({
+    width: options.width,
+    height: options.height,
+    format: options.format,
+    quality: options.quality,
+    fit: options.fit,
+    background: options.background,
+    signal: options.signal,
+});
+export const resolveFileViewerThumbnailConcurrency = (value = 2) => {
+    if (!Number.isInteger(value) || value < 1 || value > 8) {
+        throw new FileViewerThumbnailError('invalid-options', 'concurrency must be an integer between 1 and 8.');
+    }
+    return value;
+};

package/dist/types.d.ts

@@ -0,0 +1,65 @@
+import type { FileViewerOptions, FileViewerSource, FileViewerThumbnailFit, FileViewerThumbnailFormat } from '@file-viewer/core';
+export type FileViewerThumbnailErrorCode = 'browser-required' | 'unsupported' | 'timeout' | 'aborted' | 'capture-failed' | 'capture-unavailable' | 'tainted-canvas' | 'empty-output' | 'destroyed' | 'invalid-options';
+export declare class FileViewerThumbnailError extends Error {
+    readonly code: FileViewerThumbnailErrorCode;
+    readonly cause?: unknown;
+    constructor(code: FileViewerThumbnailErrorCode, message: string, cause?: unknown);
+}
+export interface FileViewerThumbnailOptions {
+    width?: number;
+    height?: number;
+    format?: FileViewerThumbnailFormat;
+    quality?: number;
+    fit?: FileViewerThumbnailFit;
+    background?: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export interface ResolvedFileViewerThumbnailOptions {
+    width: number;
+    height: number;
+    format: FileViewerThumbnailFormat;
+    quality: number;
+    fit: FileViewerThumbnailFit;
+    background: string;
+    timeoutMs: number;
+    signal?: AbortSignal;
+}
+export type FileViewerThumbnailStrategy = 'embedded' | 'provider-native' | 'provider-dom' | 'dom-fallback';
+export interface FileViewerThumbnailResult {
+    blob: Blob;
+    width: number;
+    height: number;
+    mimeType: string;
+    filename: string;
+    extension: string;
+    rendererId?: string;
+    strategy: FileViewerThumbnailStrategy;
+    degraded: boolean;
+    durationMs: number;
+}
+export interface FileViewerThumbnailBatchSuccess {
+    ok: true;
+    index: number;
+    source: FileViewerSource;
+    result: FileViewerThumbnailResult;
+}
+export interface FileViewerThumbnailBatchFailure {
+    ok: false;
+    index: number;
+    source: FileViewerSource;
+    error: FileViewerThumbnailError;
+}
+export type FileViewerThumbnailBatchItem = FileViewerThumbnailBatchSuccess | FileViewerThumbnailBatchFailure;
+export interface CreateFileViewerThumbnailGeneratorOptions {
+    viewerOptions?: FileViewerOptions;
+    concurrency?: number;
+    timeoutMs?: number;
+    document?: Document;
+}
+export interface FileViewerThumbnailGenerator {
+    generate(source: FileViewerSource, options?: FileViewerThumbnailOptions): Promise<FileViewerThumbnailResult>;
+    generateBatch(sources: readonly FileViewerSource[], options?: FileViewerThumbnailOptions): Promise<FileViewerThumbnailBatchItem[]>;
+    generateStream(sources: readonly FileViewerSource[], options?: FileViewerThumbnailOptions): AsyncIterable<FileViewerThumbnailBatchItem>;
+    destroy(): Promise<void>;
+}

package/dist/types.js

@@ -0,0 +1,8 @@
+export class FileViewerThumbnailError extends Error {
+    constructor(code, message, cause) {
+        super(message);
+        this.name = 'FileViewerThumbnailError';
+        this.code = code;
+        this.cause = cause;
+    }
+}

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@file-viewer/thumbnail",
+  "version": "2.1.26",
+  "private": false,
+  "type": "module",
+  "description": "High-performance browser thumbnail generation for Flyfish File Viewer.",
+  "keywords": [
+    "file-viewer",
+    "thumbnail",
+    "preview",
+    "batch",
+    "browser"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/flyfish-dev/file-viewer.git",
+    "directory": "packages/thumbnail"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "README.en.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@file-viewer/core": "2.1.26",
+    "epubjs": "^0.3.93",
+    "jszip": "^3.10.1",
+    "modern-screenshot": "^4.7.0"
+  },
+  "devDependencies": {
+    "happy-dom": "^20.8.4",
+    "typescript": "^6.0.3",
+    "vitest": "3.2.4"
+  },
+  "license": "Apache-2.0",
+  "scripts": {
+    "build": "node scripts/clean-dist.mjs && tsc -b tsconfig.json --force",
+    "type-check": "tsc -b tsconfig.json && tsc -p tsconfig.test.json --noEmit",
+    "test": "vitest run"
+  }
+}