@file-viewer/renderer-archive 2.0.11

package/LICENSE

@@ -0,0 +1,160 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form,
+made available under the License, as indicated by a copyright notice that is
+included in or attached to the work.
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work by
+the copyright owner or by an individual or Legal Entity authorized to submit on
+behalf of the copyright owner. For the purposes of this definition, "submitted"
+means any form of electronic, verbal, or written communication sent to the
+Licensor or its representatives, including but not limited to communication on
+electronic mailing lists, source code control systems, and issue tracking systems
+that are managed by, or on behalf of, the Licensor for the purpose of discussing
+and improving the Work, but excluding communication that is conspicuously marked
+or otherwise designated in writing by the copyright owner as "Not a
+Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this
+License, each Contributor hereby grants to You a perpetual, worldwide,
+non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+reproduce, prepare Derivative Works of, publicly display, publicly perform,
+sublicense, and distribute the Work and such Derivative Works in Source or
+Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this License,
+each Contributor hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable (except as stated in this section) patent
+license to make, have made, use, offer to sell, sell, import, and otherwise
+transfer the Work, where such license applies only to those patent claims
+licensable by such Contributor that are necessarily infringed by their
+Contribution(s) alone or by combination of their Contribution(s) with the Work to
+which such Contribution(s) was submitted. If You institute patent litigation
+against any entity (including a cross-claim or counterclaim in a lawsuit)
+alleging that the Work or a Contribution incorporated within the Work
+constitutes direct or contributory patent infringement, then any patent licenses
+granted to You under this License for that Work shall terminate as of the date
+such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or
+Derivative Works thereof in any medium, with or without modifications, and in
+Source or Object form, provided that You meet the following conditions:
+
+(a) You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+
+(b) You must cause any modified files to carry prominent notices stating that
+You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works that You
+distribute, all copyright, patent, trademark, and attribution notices from the
+Source form of the Work, excluding those notices that do not pertain to any part
+of the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its distribution, then
+any Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the Derivative
+Works; within the Source form or documentation, if provided along with the
+Derivative Works; or, within a display generated by the Derivative Works, if and
+wherever such third-party notices normally appear. The contents of the NOTICE
+file are for informational purposes only and do not modify the License. You may
+add Your own attribution notices within Derivative Works that You distribute,
+alongside or as an addendum to the NOTICE text from the Work, provided that such
+additional attribution notices cannot be construed as modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any
+Contribution intentionally submitted for inclusion in the Work by You to the
+Licensor shall be under the terms and conditions of this License, without any
+additional terms or conditions. Notwithstanding the above, nothing herein shall
+supersede or modify the terms of any separate license agreement you may have
+executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names,
+trademarks, service marks, or product names of the Licensor, except as required
+for reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+writing, Licensor provides the Work (and each Contributor provides its
+Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied, including, without limitation, any warranties or
+conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any risks
+associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in
+tort (including negligence), contract, or otherwise, unless required by
+applicable law (such as deliberate and grossly negligent acts) or agreed to in
+writing, shall any Contributor be liable to You for damages, including any
+direct, indirect, special, incidental, or consequential damages of any character
+arising as a result of this License or out of the use or inability to use the
+Work (including but not limited to damages for loss of goodwill, work stoppage,
+computer failure or malfunction, or any and all other commercial damages or
+losses), even if such Contributor has been advised of the possibility of such
+damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or
+Derivative Works thereof, You may choose to offer, and charge a fee for,
+acceptance of support, warranty, indemnity, or other liability obligations and/or
+rights consistent with this License. However, in accepting such obligations, You
+may act only on Your own behalf and on Your sole responsibility, not on behalf of
+any other Contributor, and only if You agree to indemnify, defend, and hold each
+Contributor harmless for any liability incurred by, or claims asserted against,
+such Contributor by reason of your accepting any such warranty or additional
+liability.
+
+END OF TERMS AND CONDITIONS
+
+Copyright 2026 Flyfish Viewer

package/README.en.md

@@ -0,0 +1,60 @@
+# @file-viewer/renderer-archive
+
+Standalone archive renderer package for Flyfish File Viewer. It reads ZIP, TAR, GZIP, RAR, 7z, and other archive directories with `libarchive.js` Worker + WASM, then extracts internal files only when the user opens them.
+
+## Usage
+
+```ts
+import FileViewer from '@file-viewer/vue3'
+import { archiveRenderer } from '@file-viewer/renderer-archive'
+
+const options = {
+  rendererMode: 'replace',
+  renderers: archiveRenderer,
+}
+```
+
+You can also compose it with other renderer packages:
+
+```ts
+import { archiveRenderer } from '@file-viewer/renderer-archive'
+import { pdfRenderer } from '@file-viewer/renderer-pdf'
+import { cadRenderer } from '@file-viewer/renderer-cad'
+
+const options = {
+  rendererMode: 'replace',
+  renderers: [pdfRenderer, cadRenderer, archiveRenderer],
+}
+```
+
+## Capabilities
+
+- Previews ZIP, TAR, GZIP, RAR, 7z, and common archive directories.
+- Uses `libarchive.js` Worker + WASM first to keep large archive parsing off the main thread.
+- Falls back to ZIP / TAR / GZIP parsing when the Worker cannot be started, which helps mobile WebViews, local static servers, and private intranet deployments.
+- Extracts internal files on demand, then delegates nested previews through `renderNestedBuffer` or the core dispatcher.
+- Includes archive size limits, entry preview limits, worker timeout, IndexedDB cache, and single-entry download.
+
+## Offline Assets
+
+Default asset paths are:
+
+- `vendor/libarchive/worker-bundle.js`
+- `vendor/libarchive/libarchive.wasm`
+
+For private deployments, override them with `options.archive.workerUrl` and `options.archive.wasmUrl`.
+
+```ts
+const options = {
+  archive: {
+    workerUrl: '/file-viewer/vendor/libarchive/worker-bundle.js',
+    wasmUrl: '/file-viewer/vendor/libarchive/libarchive.wasm',
+    cache: true,
+    workerTimeoutMs: 30000,
+  },
+}
+```
+
+## Migration Note
+
+The core package no longer bundles the archive renderer and no longer installs `libarchive.js` for the archive pipeline. ZIP/TAR/GZIP fallback, `jszip`, cache, and Worker logic are owned by this package; core may still temporarily retain `jszip` for the OFD vendor path until OFD is fully extracted. Install this renderer explicitly, or use `@file-viewer/preset-all`, when archive preview is required.

package/README.md

@@ -0,0 +1,60 @@
+# @file-viewer/renderer-archive
+
+Flyfish File Viewer 的独立压缩包 renderer 包。它用 `libarchive.js` Worker + WASM 读取 RAR、7z、ZIP、TAR 等压缩包目录，并在点击内部文件时才按需解压、缓存和调用 File Viewer 的嵌套渲染能力。
+
+## 用法
+
+```ts
+import FileViewer from '@file-viewer/vue3'
+import { archiveRenderer } from '@file-viewer/renderer-archive'
+
+const options = {
+  rendererMode: 'replace',
+  renderers: archiveRenderer,
+}
+```
+
+也可以和其他 renderer 一起组合：
+
+```ts
+import { archiveRenderer } from '@file-viewer/renderer-archive'
+import { pdfRenderer } from '@file-viewer/renderer-pdf'
+import { cadRenderer } from '@file-viewer/renderer-cad'
+
+const options = {
+  rendererMode: 'replace',
+  renderers: [pdfRenderer, cadRenderer, archiveRenderer],
+}
+```
+
+## 能力边界
+
+- 支持 ZIP、TAR、GZIP、RAR、7z 等常见压缩包目录预览。
+- 优先使用 `libarchive.js` Worker + WASM，避免大压缩包阻塞主线程。
+- Worker 不可用时自动回退到 ZIP / TAR / GZIP 兼容模式，适合手机 WebView、本地临时服务器和内网静态部署排障。
+- 点击内部文件后才按需解压，并通过 `renderNestedBuffer` 或 core dispatcher 复用 PDF、Office、CAD、XMind、图片、代码等现有 renderer。
+- 内置体积上限、单文件预览上限、Worker 超时、IndexedDB 缓存和下载入口，避免一次性把压缩包全部展开到内存。
+
+## 离线资产
+
+默认会从 viewer assets 下读取：
+
+- `vendor/libarchive/worker-bundle.js`
+- `vendor/libarchive/libarchive.wasm`
+
+私有化部署时可以通过 `options.archive.workerUrl` 和 `options.archive.wasmUrl` 覆盖。
+
+```ts
+const options = {
+  archive: {
+    workerUrl: '/file-viewer/vendor/libarchive/worker-bundle.js',
+    wasmUrl: '/file-viewer/vendor/libarchive/libarchive.wasm',
+    cache: true,
+    workerTimeoutMs: 30000,
+  },
+}
+```
+
+## 迁移说明
+
+`@file-viewer/core` 已不再内置 archive renderer，也不再为压缩包链路直接安装 `libarchive.js`。ZIP/TAR/GZIP fallback、`jszip`、缓存和 Worker 逻辑由本包维护；core 在 OFD 完全拆出前可能仍会因 OFD vendor 临时保留 `jszip`。需要压缩包预览时，请显式安装本包，或直接使用 `@file-viewer/preset-all` 聚合能力。

package/dist/archive.d.ts

@@ -0,0 +1,2 @@
+import { type FileRenderContext, type FileViewerRenderedInstance } from '@file-viewer/core';
+export default function renderArchive(buffer: ArrayBuffer, target: HTMLDivElement, _type?: string, context?: FileRenderContext): Promise<FileViewerRenderedInstance>;

package/dist/archive.js

@@ -0,0 +1,547 @@
+import { resolveFileViewerArchiveWasmUrl, resolveFileViewerArchiveWorkerUrl, } from '@file-viewer/core/assets';
+import { disposeFileViewerRendered, } from '@file-viewer/core';
+import { createArchiveCacheKey, flattenArchiveObject, formatArchiveBytes, getArchiveEntryExtension, } from './archiveShared.js';
+import { readArchiveCache, writeArchiveCache } from './archiveCache.js';
+import { loadArchiveEntriesWithoutWorker } from './archiveFallback.js';
+const DEFAULT_MAX_ARCHIVE_SIZE = 320 * 1024 * 1024;
+const DEFAULT_MAX_ENTRY_PREVIEW_SIZE = 64 * 1024 * 1024;
+const DEFAULT_WORKER_TIMEOUT_MS = 30000;
+const MAX_LISTED_ENTRIES = 5000;
+const archiveStyle = `
+.archive-shell,.archive-viewer{position:relative;box-sizing:border-box;height:100%;min-height:0;display:grid;grid-template-columns:minmax(280px,34%) minmax(0,1fr);background:#edf2f7;color:#172033;font-family:Aptos,'Segoe UI','PingFang SC','Microsoft YaHei',sans-serif}
+.archive-shell *,.archive-viewer *{box-sizing:border-box}
+.archive-sidebar{min-width:0;min-height:0;display:flex;flex-direction:column;gap:12px;padding:16px;border-right:1px solid rgba(23,32,51,.08);background:rgba(255,255,255,.72)}
+.archive-head span,.archive-preview-toolbar span{color:#6c7c90;font-size:12px;font-weight:800;letter-spacing:0}
+.archive-head strong,.archive-preview-toolbar strong{display:block;margin-top:4px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;font-size:18px;line-height:1.25}
+.archive-head p{margin:8px 0 0;color:#69798b;font-size:13px}
+.archive-warning,.archive-info,.archive-error{border-radius:12px;padding:10px 12px;background:#fff7e8;color:#8a4b00;font-size:13px;line-height:1.5}
+.archive-info{background:#ecfdf5;color:#166534}
+.archive-search{width:100%;height:42px;padding:0 12px;border-radius:12px;border:1px solid rgba(23,32,51,.1);outline:none;background:#fff;color:#172033;font:inherit}
+.archive-list{flex:1;min-height:0;overflow:auto;display:flex;flex-direction:column;gap:7px;padding-right:4px}
+.archive-entry{width:100%;min-height:58px;display:grid;grid-template-columns:42px minmax(0,1fr) auto;gap:10px;align-items:center;padding:8px 10px 8px calc(10px + var(--entry-depth,0) * 10px);border:1px solid rgba(23,32,51,.07);border-radius:12px;background:rgba(255,255,255,.86);color:inherit;text-align:left;cursor:pointer;font:inherit}
+.archive-entry:hover,.archive-entry.active{border-color:rgba(33,129,95,.28);box-shadow:0 10px 22px rgba(23,32,51,.08)}
+.entry-ext{height:34px;display:inline-flex;align-items:center;justify-content:center;border-radius:10px;background:rgba(33,129,95,.12);color:#1d7a56;font-size:11px;font-weight:900;text-transform:uppercase}
+.entry-copy{min-width:0}
+.entry-copy strong,.entry-copy em{display:block;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.entry-copy em,.archive-entry small{color:#718096;font-size:12px;font-style:normal}
+.archive-preview{min-width:0;min-height:0;display:flex;flex-direction:column}
+.archive-preview-toolbar{min-height:64px;display:flex;align-items:center;justify-content:space-between;gap:14px;padding:12px 16px;border-bottom:1px solid rgba(23,32,51,.08);background:rgba(255,255,255,.76)}
+.archive-preview-toolbar button{height:34px;border:0;border-radius:10px;padding:0 12px;background:#1f7a58;color:#fff;font:inherit;font-size:13px;font-weight:800;cursor:pointer}
+.archive-nested-target{position:relative;flex:1;min-height:0;overflow:auto}
+.archive-nested-content{width:100%;height:100%;min-height:420px}
+.archive-empty{height:100%;display:flex;flex-direction:column;align-items:center;justify-content:center;padding:28px;text-align:center;color:#64748b}
+.archive-empty strong{color:#172033;font-size:18px}
+.archive-state{position:absolute;inset:0;display:flex;align-items:center;justify-content:center;background:rgba(241,245,249,.82);backdrop-filter:blur(8px);z-index:4}
+.archive-state>div{display:flex;align-items:center;gap:14px;width:min(92%,430px);padding:18px;border-radius:16px;background:#fff;box-shadow:0 18px 42px rgba(15,23,42,.14)}
+.archive-state p{margin:4px 0 0;color:#64748b}
+.archive-spinner{width:34px;height:34px;flex-shrink:0;border-radius:999px;border:3px solid rgba(31,122,88,.16);border-top-color:#1f7a58;animation:archive-spin .9s linear infinite}
+.archive-error{position:absolute;right:18px;bottom:18px;width:min(460px,calc(100% - 36px));box-shadow:0 16px 36px rgba(23,32,51,.14);z-index:5}
+.archive-hidden{display:none!important}
+.file-viewer[data-viewer-theme='dark'] .archive-shell,.file-viewer[data-viewer-theme='dark'] .archive-viewer{background:#101820;color:#e6edf3}
+.file-viewer[data-viewer-theme='dark'] .archive-sidebar,.file-viewer[data-viewer-theme='dark'] .archive-preview-toolbar{border-color:rgba(139,148,158,.2);background:rgba(21,27,35,.82)}
+.file-viewer[data-viewer-theme='dark'] .archive-entry,.file-viewer[data-viewer-theme='dark'] .archive-search,.file-viewer[data-viewer-theme='dark'] .archive-state>div{background:#151b23;color:#e6edf3;border-color:rgba(139,148,158,.2)}
+.file-viewer[data-viewer-theme='dark'] .archive-empty strong{color:#f8fafc}
+@media (prefers-color-scheme:dark){.file-viewer[data-viewer-theme='system'] .archive-shell,.file-viewer[data-viewer-theme='system'] .archive-viewer{background:#101820;color:#e6edf3}.file-viewer[data-viewer-theme='system'] .archive-sidebar,.file-viewer[data-viewer-theme='system'] .archive-preview-toolbar{border-color:rgba(139,148,158,.2);background:rgba(21,27,35,.82)}.file-viewer[data-viewer-theme='system'] .archive-entry,.file-viewer[data-viewer-theme='system'] .archive-search,.file-viewer[data-viewer-theme='system'] .archive-state>div{background:#151b23;color:#e6edf3;border-color:rgba(139,148,158,.2)}.file-viewer[data-viewer-theme='system'] .archive-empty strong{color:#f8fafc}}
+@keyframes archive-spin{to{transform:rotate(360deg)}}
+@media (max-width:860px){.archive-shell,.archive-viewer{grid-template-columns:1fr;grid-template-rows:minmax(220px,38%) minmax(0,1fr)}.archive-sidebar{border-right:0;border-bottom:1px solid rgba(23,32,51,.08)}}
+`;
+const createStyle = (documentRef) => {
+    const style = documentRef.createElement('style');
+    style.textContent = archiveStyle;
+    return style;
+};
+const createElement = (documentRef, tagName, className, text) => {
+    const element = documentRef.createElement(tagName);
+    if (className) {
+        element.className = className;
+    }
+    if (text !== undefined) {
+        element.textContent = text;
+    }
+    return element;
+};
+const normalizeWorkerError = (reason) => {
+    if (reason instanceof Error) {
+        return reason.message;
+    }
+    return typeof reason === 'string' ? reason : JSON.stringify(reason);
+};
+const withTimeout = async (promise, timeout, message, targetWindow) => {
+    let timer = 0;
+    const timerWindow = targetWindow || (typeof window !== 'undefined' ? window : undefined);
+    try {
+        return await Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                timer = (timerWindow === null || timerWindow === void 0 ? void 0 : timerWindow.setTimeout)
+                    ? timerWindow.setTimeout(() => reject(new Error(message)), timeout)
+                    : setTimeout(() => reject(new Error(message)), timeout);
+            }),
+        ]);
+    }
+    finally {
+        if (timerWindow === null || timerWindow === void 0 ? void 0 : timerWindow.clearTimeout) {
+            timerWindow.clearTimeout(timer);
+        }
+        else {
+            clearTimeout(timer);
+        }
+    }
+};
+const getDocumentBaseUrl = (documentRef) => {
+    return documentRef.baseURI ||
+        documentRef.URL ||
+        'http://localhost/';
+};
+const getWorkerConstructor = (documentRef) => {
+    var _a;
+    const WorkerCtor = ((_a = documentRef.defaultView) === null || _a === void 0 ? void 0 : _a.Worker) ||
+        (typeof Worker !== 'undefined' ? Worker : undefined);
+    if (!WorkerCtor) {
+        throw new Error('当前浏览器不支持 Web Worker');
+    }
+    return WorkerCtor;
+};
+const getFileConstructor = (documentRef) => {
+    var _a;
+    return (((_a = documentRef.defaultView) === null || _a === void 0 ? void 0 : _a.File) ||
+        (typeof File !== 'undefined' ? File : undefined));
+};
+const createArchiveFile = (documentRef, buffer, filename) => {
+    const FileCtor = getFileConstructor(documentRef);
+    if (FileCtor) {
+        return new FileCtor([buffer], filename || 'archive.bin', {
+            type: 'application/octet-stream',
+        });
+    }
+    return Object.assign(new Blob([buffer], { type: 'application/octet-stream' }), {
+        name: filename || 'archive.bin',
+    });
+};
+const probeWorkerUrl = async (url) => {
+    try {
+        const response = await fetch(url, { method: 'HEAD', cache: 'no-cache' });
+        const contentType = response.headers.get('content-type') || '';
+        if (response.ok && /javascript|ecmascript|octet-stream/i.test(contentType)) {
+            return true;
+        }
+        if (response.status && response.status !== 405) {
+            return false;
+        }
+    }
+    catch {
+        // Some local servers do not support HEAD; continue with a tiny GET probe.
+    }
+    try {
+        const response = await fetch(url, {
+            method: 'GET',
+            cache: 'no-cache',
+            headers: {
+                Range: 'bytes=0-0',
+            },
+        });
+        const contentType = response.headers.get('content-type') || '';
+        return response.ok && /javascript|ecmascript|octet-stream/i.test(contentType);
+    }
+    catch {
+        return false;
+    }
+};
+const patchLibarchiveWorkerSource = (source, wasmUrl) => {
+    const wasmLiteral = JSON.stringify(wasmUrl);
+    return source.replace(/new URL\((['"])libarchive\.wasm\1\s*,\s*import\.meta\.url\)\.href/g, wasmLiteral);
+};
+const prepareWorkerUrl = async (candidate, objectUrls) => {
+    if (!candidate.wasmUrl) {
+        return candidate.workerUrl;
+    }
+    const response = await fetch(candidate.workerUrl, { cache: 'no-cache' });
+    if (!response.ok) {
+        throw new Error(`无法读取 libarchive Worker: ${response.status}`);
+    }
+    const source = await response.text();
+    const workerUrl = URL.createObjectURL(new Blob([
+        patchLibarchiveWorkerSource(source, candidate.wasmUrl),
+    ], { type: 'application/javascript' }));
+    objectUrls.push(workerUrl);
+    return workerUrl;
+};
+const resolveWorkerCandidates = async (documentRef, options) => {
+    const candidates = [];
+    const baseUrl = getDocumentBaseUrl(documentRef);
+    const wasmUrl = (options === null || options === void 0 ? void 0 : options.wasmUrl)
+        ? resolveFileViewerArchiveWasmUrl(options, '')
+        : undefined;
+    if (options === null || options === void 0 ? void 0 : options.workerUrl) {
+        candidates.push({
+            label: '自定义 libarchive Worker',
+            workerUrl: resolveFileViewerArchiveWorkerUrl(options, baseUrl),
+            wasmUrl,
+        });
+        return candidates;
+    }
+    const publicWorkerUrl = resolveFileViewerArchiveWorkerUrl(undefined, baseUrl);
+    if (await probeWorkerUrl(publicWorkerUrl)) {
+        candidates.push({
+            label: '静态 libarchive Worker',
+            workerUrl: publicWorkerUrl,
+            wasmUrl,
+        });
+    }
+    return candidates;
+};
+const buildNestedOptions = (context, archiveOptions) => ({
+    ...((context === null || context === void 0 ? void 0 : context.options) || {}),
+    archive: archiveOptions,
+});
+const renderNestedWithCoreFallback = async (buffer, type, target, context) => {
+    const { fileViewerCoreRendererDispatcher } = await import('@file-viewer/core');
+    const handler = fileViewerCoreRendererDispatcher.resolve(type);
+    if (!handler) {
+        target.textContent = `不支持.${type}格式的在线预览，请下载后预览或转换为支持的格式`;
+        return undefined;
+    }
+    return handler(buffer, target, type, {
+        ...context,
+        renderNestedBuffer: (context === null || context === void 0 ? void 0 : context.renderNestedBuffer) || renderNestedWithCoreFallback,
+    });
+};
+export default async function renderArchive(buffer, target, _type, context) {
+    var _a;
+    const documentRef = target.ownerDocument;
+    const targetWindow = documentRef.defaultView || null;
+    const archiveOptions = (_a = context === null || context === void 0 ? void 0 : context.options) === null || _a === void 0 ? void 0 : _a.archive;
+    const filename = (context === null || context === void 0 ? void 0 : context.filename) || 'archive.bin';
+    const maxArchiveSize = (archiveOptions === null || archiveOptions === void 0 ? void 0 : archiveOptions.maxArchiveSize) || DEFAULT_MAX_ARCHIVE_SIZE;
+    const maxEntryPreviewSize = (archiveOptions === null || archiveOptions === void 0 ? void 0 : archiveOptions.maxEntryPreviewSize) || DEFAULT_MAX_ENTRY_PREVIEW_SIZE;
+    const cacheEnabled = (archiveOptions === null || archiveOptions === void 0 ? void 0 : archiveOptions.cache) !== false;
+    const workerTimeoutMs = (archiveOptions === null || archiveOptions === void 0 ? void 0 : archiveOptions.workerTimeoutMs) || DEFAULT_WORKER_TIMEOUT_MS;
+    const objectUrls = [];
+    const cleanups = [];
+    let archiveReader = null;
+    let entries = [];
+    let selectedEntry = null;
+    let nestedRendered;
+    let loading = false;
+    let loadingText = '正在读取压缩包目录...';
+    let loadingHint = '大文件会在 Worker 中解析，避免阻塞主线程。';
+    let errorText = '';
+    let archiveNotice = '';
+    let encrypted = null;
+    let filterText = '';
+    const style = createStyle(documentRef);
+    const root = createElement(documentRef, 'section', 'archive-shell archive-viewer');
+    const sidebar = createElement(documentRef, 'aside', 'archive-sidebar');
+    const head = createElement(documentRef, 'div', 'archive-head');
+    const badge = createElement(documentRef, 'span', undefined, 'ARCHIVE');
+    const title = createElement(documentRef, 'strong', undefined, filename);
+    const stats = createElement(documentRef, 'p');
+    head.append(badge, title, stats);
+    const warning = createElement(documentRef, 'div', 'archive-warning');
+    const info = createElement(documentRef, 'div', 'archive-info');
+    const search = createElement(documentRef, 'input', 'archive-search');
+    search.type = 'search';
+    search.placeholder = '筛选压缩包内文件';
+    const list = createElement(documentRef, 'div', 'archive-list');
+    list.setAttribute('role', 'list');
+    sidebar.append(head, warning, info, search, list);
+    const preview = createElement(documentRef, 'main', 'archive-preview');
+    const toolbar = createElement(documentRef, 'div', 'archive-preview-toolbar');
+    const toolbarTitle = createElement(documentRef, 'div');
+    toolbarTitle.append(createElement(documentRef, 'span', undefined, '压缩包内预览'), createElement(documentRef, 'strong', undefined, '请选择一个文件'));
+    const downloadButton = createElement(documentRef, 'button', undefined, '下载文件');
+    downloadButton.type = 'button';
+    toolbar.append(toolbarTitle, downloadButton);
+    const nestedTarget = createElement(documentRef, 'div', 'archive-nested-target');
+    preview.append(toolbar, nestedTarget);
+    root.append(sidebar, preview);
+    const state = createElement(documentRef, 'div', 'archive-state');
+    const stateContent = createElement(documentRef, 'div');
+    const spinner = createElement(documentRef, 'span', 'archive-spinner');
+    const stateCopy = createElement(documentRef, 'div');
+    const stateTitle = createElement(documentRef, 'strong', undefined, loadingText);
+    const stateHint = createElement(documentRef, 'p', undefined, loadingHint);
+    stateCopy.append(stateTitle, stateHint);
+    stateContent.append(spinner, stateCopy);
+    state.append(stateContent);
+    root.append(state);
+    const error = createElement(documentRef, 'div', 'archive-error');
+    const errorTitle = createElement(documentRef, 'strong', undefined, '压缩包预览提示');
+    const errorMessage = createElement(documentRef, 'p');
+    error.append(errorTitle, errorMessage);
+    root.append(error);
+    target.replaceChildren(style, root);
+    const listen = (element, event, listener) => {
+        element.addEventListener(event, listener);
+        cleanups.push(() => element.removeEventListener(event, listener));
+    };
+    const getArchiveStats = () => {
+        const totalSize = entries.reduce((sum, entry) => sum + entry.size, 0);
+        const previewableCount = entries.filter(entry => entry.previewable).length;
+        return {
+            count: entries.length,
+            totalSize,
+            previewableCount,
+        };
+    };
+    const getFilteredEntries = () => {
+        const keyword = filterText.trim().toLowerCase();
+        const source = keyword
+            ? entries.filter(entry => entry.path.toLowerCase().includes(keyword))
+            : entries;
+        return source.slice(0, MAX_LISTED_ENTRIES);
+    };
+    const clearNestedPreview = async () => {
+        await disposeFileViewerRendered(nestedRendered);
+        nestedRendered = undefined;
+        nestedTarget.replaceChildren();
+    };
+    const closeArchive = async () => {
+        var _a;
+        await ((_a = archiveReader === null || archiveReader === void 0 ? void 0 : archiveReader.close) === null || _a === void 0 ? void 0 : _a.call(archiveReader));
+        archiveReader = null;
+    };
+    const syncState = () => {
+        const archiveStats = getArchiveStats();
+        stats.textContent = `${archiveStats.count} 个文件 · ${formatArchiveBytes(archiveStats.totalSize)} · ${archiveStats.previewableCount} 个可直接预览`;
+        warning.textContent = '检测到加密内容，当前在线预览不接收密码，建议下载后本地解压。';
+        warning.classList.toggle('archive-hidden', !encrypted);
+        info.textContent = archiveNotice;
+        info.classList.toggle('archive-hidden', !archiveNotice);
+        state.classList.toggle('archive-hidden', !loading);
+        stateTitle.textContent = loadingText;
+        stateHint.textContent = loadingHint;
+        error.classList.toggle('archive-hidden', !errorText);
+        errorMessage.textContent = errorText;
+        downloadButton.hidden = !selectedEntry;
+        const activeTitle = toolbarTitle.querySelector('strong');
+        if (activeTitle) {
+            activeTitle.textContent = (selectedEntry === null || selectedEntry === void 0 ? void 0 : selectedEntry.name) || '请选择一个文件';
+        }
+    };
+    const renderEmptyState = () => {
+        if (selectedEntry || loading || nestedTarget.childElementCount) {
+            return;
+        }
+        const empty = createElement(documentRef, 'div', 'archive-empty');
+        empty.append(createElement(documentRef, 'strong', undefined, '选择左侧文件即可预览'), createElement(documentRef, 'p', undefined, '压缩包只读取目录；文件内容会在点击后按需解压，并在体积允许时缓存到 IndexedDB。'));
+        nestedTarget.replaceChildren(empty);
+    };
+    const renderEntryList = () => {
+        list.replaceChildren();
+        getFilteredEntries().forEach(entry => {
+            const button = createElement(documentRef, 'button', 'archive-entry');
+            button.type = 'button';
+            button.style.setProperty('--entry-depth', String(entry.depth));
+            button.classList.toggle('active', (selectedEntry === null || selectedEntry === void 0 ? void 0 : selectedEntry.id) === entry.id);
+            const icon = createElement(documentRef, 'span', 'entry-ext', entry.extension || 'file');
+            const copy = createElement(documentRef, 'span', 'entry-copy');
+            copy.append(createElement(documentRef, 'strong', undefined, entry.name), createElement(documentRef, 'em', undefined, entry.path));
+            button.append(icon, copy, createElement(documentRef, 'small', undefined, formatArchiveBytes(entry.size)));
+            button.addEventListener('click', () => {
+                void previewEntry(entry);
+            });
+            list.append(button);
+        });
+    };
+    const setLoading = (next, text, hint) => {
+        loading = next;
+        if (text) {
+            loadingText = text;
+        }
+        if (hint) {
+            loadingHint = hint;
+        }
+        syncState();
+        renderEmptyState();
+    };
+    const setError = (message) => {
+        errorText = message;
+        syncState();
+    };
+    const terminateWorkers = (workers) => {
+        workers.forEach(worker => worker.terminate());
+        workers.length = 0;
+    };
+    const tryOpenArchiveWithWorker = async (Archive, candidate) => {
+        const createdWorkers = [];
+        const workerUrl = await prepareWorkerUrl(candidate, objectUrls);
+        const WorkerCtor = getWorkerConstructor(documentRef);
+        try {
+            Archive.init({
+                getWorker: () => {
+                    const worker = new WorkerCtor(workerUrl, { type: 'module' });
+                    createdWorkers.push(worker);
+                    return worker;
+                },
+            });
+            setLoading(true, `正在初始化${candidate.label}...`, '如果当前服务器没有正确发布 Worker/WASM，会自动切换兼容模式。');
+            const archiveFile = createArchiveFile(documentRef, buffer, filename);
+            const archive = await withTimeout(Archive.open(archiveFile), workerTimeoutMs, `${candidate.label} 初始化超时`, targetWindow);
+            archiveReader = archive;
+            encrypted = await withTimeout(archive.hasEncryptedData(), workerTimeoutMs, `${candidate.label} 加密检测超时`, targetWindow).catch(() => null);
+            setLoading(true, '正在读取压缩包目录...', '目录读取完成后，点击内部文件才会按需解压。');
+            const fileTree = await withTimeout(archive.getFilesObject(), workerTimeoutMs, `${candidate.label} 读取目录超时`, targetWindow);
+            entries = flattenArchiveObject(fileTree)
+                .sort((left, right) => left.path.localeCompare(right.path));
+            syncState();
+            renderEntryList();
+            renderEmptyState();
+            return true;
+        }
+        catch (reason) {
+            if (!archiveReader) {
+                terminateWorkers(createdWorkers);
+            }
+            throw reason;
+        }
+    };
+    const tryOpenArchiveWithFallback = async () => {
+        setLoading(true, 'Worker 不可用，正在切换 ZIP/TAR 兼容模式...', '兼容模式无需额外静态 Worker，适合手机 WebView 或本地临时服务器。');
+        const fallbackEntries = await loadArchiveEntriesWithoutWorker(buffer, filename);
+        if (!fallbackEntries) {
+            return false;
+        }
+        entries = fallbackEntries.sort((left, right) => left.path.localeCompare(right.path));
+        encrypted = null;
+        archiveNotice = '当前环境的 libarchive Worker 未能启动，已自动切换到 ZIP/TAR/GZIP 兼容模式。RAR、7z 等格式仍建议发布 vendor/libarchive/worker-bundle.js 与 libarchive.wasm。';
+        syncState();
+        renderEntryList();
+        renderEmptyState();
+        return true;
+    };
+    const openArchive = async () => {
+        if (buffer.byteLength > maxArchiveSize) {
+            setError(`压缩包体积 ${formatArchiveBytes(buffer.byteLength)} 超过安全上限 ${formatArchiveBytes(maxArchiveSize)}，请下载后在本地解压。`);
+            return;
+        }
+        setLoading(true, '正在初始化压缩包解析 Worker...', '大文件会在 Worker 中解析，避免阻塞主线程。');
+        setError('');
+        archiveNotice = '';
+        try {
+            const [{ Archive }, candidates] = await Promise.all([
+                import('libarchive.js'),
+                resolveWorkerCandidates(documentRef, archiveOptions),
+            ]);
+            const errors = [];
+            for (const candidate of candidates) {
+                try {
+                    await closeArchive();
+                    await tryOpenArchiveWithWorker(Archive, candidate);
+                    return;
+                }
+                catch (reason) {
+                    errors.push(`${candidate.label}: ${normalizeWorkerError(reason)}`);
+                }
+            }
+            await closeArchive();
+            if (await tryOpenArchiveWithFallback()) {
+                return;
+            }
+            throw new Error(errors.join('；') || '压缩包 Worker 初始化失败');
+        }
+        catch (nextError) {
+            console.error(nextError);
+            setError(nextError instanceof Error ? nextError.message : String(nextError));
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    const renderEntryBuffer = async (entry, entryBuffer) => {
+        await clearNestedPreview();
+        const child = createElement(documentRef, 'div', 'archive-nested-content');
+        nestedTarget.append(child);
+        const nestedContext = {
+            ...context,
+            filename: entry.name,
+            options: buildNestedOptions(context, archiveOptions),
+        };
+        nestedRendered = (context === null || context === void 0 ? void 0 : context.renderNestedBuffer)
+            ? await context.renderNestedBuffer(entryBuffer, entry.extension, child, nestedContext)
+            : await renderNestedWithCoreFallback(entryBuffer, entry.extension, child, nestedContext);
+    };
+    const extractEntryBuffer = async (entry) => {
+        const cacheKey = createArchiveCacheKey(filename, buffer.byteLength, entry);
+        if (cacheEnabled) {
+            const cached = await readArchiveCache(cacheKey);
+            if (cached) {
+                return cached.buffer;
+            }
+        }
+        const file = await entry.compressedFile.extract();
+        const entryBuffer = await file.arrayBuffer();
+        if (cacheEnabled) {
+            await writeArchiveCache({
+                key: cacheKey,
+                filename: entry.name,
+                size: entryBuffer.byteLength,
+                updatedAt: Date.now(),
+                buffer: entryBuffer,
+            });
+        }
+        return entryBuffer;
+    };
+    async function previewEntry(entry) {
+        selectedEntry = entry;
+        renderEntryList();
+        syncState();
+        if (entry.size > maxEntryPreviewSize) {
+            setError(`压缩包内文件 ${entry.name} 体积 ${formatArchiveBytes(entry.size)} 超过预览上限 ${formatArchiveBytes(maxEntryPreviewSize)}。`);
+            return;
+        }
+        setLoading(true, `正在按需解压 ${entry.name}...`);
+        setError('');
+        try {
+            const entryBuffer = await extractEntryBuffer(entry);
+            setLoading(true, `正在渲染 ${entry.name}...`);
+            await renderEntryBuffer(entry, entryBuffer);
+        }
+        catch (nextError) {
+            console.error(nextError);
+            setError(nextError instanceof Error ? nextError.message : String(nextError));
+        }
+        finally {
+            setLoading(false);
+        }
+    }
+    const downloadEntry = async (entry) => {
+        setLoading(true, `正在导出 ${entry.name}...`);
+        try {
+            const entryBuffer = await extractEntryBuffer(entry);
+            const url = URL.createObjectURL(new Blob([entryBuffer]));
+            objectUrls.push(url);
+            const link = documentRef.createElement('a');
+            link.href = url;
+            link.download = entry.name;
+            documentRef.body.append(link);
+            link.click();
+            link.remove();
+        }
+        finally {
+            setLoading(false);
+        }
+    };
+    listen(search, 'input', () => {
+        filterText = search.value;
+        renderEntryList();
+    });
+    listen(downloadButton, 'click', () => {
+        if (selectedEntry) {
+            void downloadEntry(selectedEntry);
+        }
+    });
+    syncState();
+    renderEmptyState();
+    void openArchive();
+    return {
+        $el: root,
+        async unmount() {
+            cleanups.splice(0).forEach(cleanup => cleanup());
+            await clearNestedPreview();
+            await closeArchive();
+            objectUrls.forEach(url => URL.revokeObjectURL(url));
+            target.replaceChildren();
+        },
+    };
+}

package/dist/archiveCache.d.ts

@@ -0,0 +1,10 @@
+interface CachedArchiveEntry {
+    key: string;
+    filename: string;
+    size: number;
+    updatedAt: number;
+    buffer: ArrayBuffer;
+}
+export declare const readArchiveCache: (key: string) => Promise<CachedArchiveEntry | null>;
+export declare const writeArchiveCache: (entry: CachedArchiveEntry) => Promise<void>;
+export {};

package/dist/archiveCache.js

@@ -0,0 +1,96 @@
+const DB_NAME = 'flyfish-file-viewer-cache';
+const STORE_NAME = 'archiveEntries';
+const DB_VERSION = 1;
+const MAX_CACHE_ENTRY_BYTES = 24 * 1024 * 1024;
+const MAX_CACHE_TOTAL_BYTES = 96 * 1024 * 1024;
+let dbPromise = null;
+const canUseIndexedDB = () => typeof indexedDB !== 'undefined';
+const openCacheDb = () => {
+    if (!canUseIndexedDB()) {
+        return Promise.reject(new Error('IndexedDB 不可用'));
+    }
+    if (dbPromise) {
+        return dbPromise;
+    }
+    dbPromise = new Promise((resolve, reject) => {
+        const request = indexedDB.open(DB_NAME, DB_VERSION);
+        request.onupgradeneeded = () => {
+            const db = request.result;
+            if (!db.objectStoreNames.contains(STORE_NAME)) {
+                const store = db.createObjectStore(STORE_NAME, { keyPath: 'key' });
+                store.createIndex('updatedAt', 'updatedAt');
+            }
+        };
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+    });
+    return dbPromise;
+};
+const runStore = async (mode, runner) => {
+    const db = await openCacheDb();
+    return new Promise((resolve, reject) => {
+        const transaction = db.transaction(STORE_NAME, mode);
+        const request = runner(transaction.objectStore(STORE_NAME));
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+        transaction.onerror = () => reject(transaction.error);
+    });
+};
+export const readArchiveCache = async (key) => {
+    try {
+        const cached = await runStore('readonly', store => store.get(key));
+        return cached || null;
+    }
+    catch {
+        return null;
+    }
+};
+const pruneArchiveCache = async () => {
+    try {
+        const db = await openCacheDb();
+        await new Promise((resolve, reject) => {
+            const transaction = db.transaction(STORE_NAME, 'readwrite');
+            const store = transaction.objectStore(STORE_NAME);
+            const index = store.index('updatedAt');
+            const entries = [];
+            let total = 0;
+            index.openCursor().onsuccess = event => {
+                const cursor = event.target.result;
+                if (!cursor) {
+                    while (total > MAX_CACHE_TOTAL_BYTES && entries.length) {
+                        const entry = entries.shift();
+                        if (entry) {
+                            total -= entry.size;
+                            store.delete(entry.key);
+                        }
+                    }
+                    return;
+                }
+                const value = cursor.value;
+                total += value.size || 0;
+                entries.push({ key: value.key, size: value.size || 0 });
+                cursor.continue();
+            };
+            transaction.oncomplete = () => resolve();
+            transaction.onerror = () => reject(transaction.error);
+        });
+    }
+    catch {
+        // Cache pruning is a best-effort optimization and must not block preview.
+    }
+};
+export const writeArchiveCache = async (entry) => {
+    if (entry.size > MAX_CACHE_ENTRY_BYTES) {
+        return;
+    }
+    try {
+        await runStore('readwrite', store => store.put({
+            ...entry,
+            updatedAt: Date.now(),
+        }));
+        await pruneArchiveCache();
+    }
+    catch {
+        // Quota, private-mode, or browser policy errors simply disable cache writes.
+    }
+};

package/dist/archiveFallback.d.ts

@@ -0,0 +1,7 @@
+import { type ArchiveEntryView } from './archiveShared.js';
+/**
+ * Worker fallback for constrained browsers, temporary local servers, and
+ * mobile WebViews. The main libarchive path still covers broader formats;
+ * this covers common ZIP/TAR/GZIP archives without an extra static Worker.
+ */
+export declare const loadArchiveEntriesWithoutWorker: (data: ArrayBuffer, filename: string) => Promise<ArchiveEntryView[] | null>;

package/dist/archiveFallback.js

@@ -0,0 +1,166 @@
+import { getArchiveEntryExtension, isPreviewableArchiveEntry, } from './archiveShared.js';
+const ZIP_LIKE_EXTENSIONS = new Set(['zip', 'zipx', 'jar', 'war', 'ear', 'apk', 'cbz']);
+const TAR_LIKE_EXTENSIONS = new Set(['tar', 'tgz', 'gz', 'gzip']);
+const TAR_BLOCK_SIZE = 512;
+const toArrayBuffer = (bytes) => {
+    const output = new Uint8Array(bytes.byteLength);
+    output.set(bytes);
+    return output.buffer;
+};
+const decompressBytes = async (bytes, format) => {
+    if (typeof DecompressionStream === 'undefined') {
+        return null;
+    }
+    const stream = new Blob([toArrayBuffer(bytes)])
+        .stream()
+        .pipeThrough(new DecompressionStream(format));
+    return new Uint8Array(await new Response(stream).arrayBuffer());
+};
+const normalizeArchivePath = (path) => {
+    return path.replace(/^\/+/, '').replace(/\\/g, '/');
+};
+const getPathName = (path) => {
+    const parts = normalizeArchivePath(path).split('/');
+    return parts[parts.length - 1] || path;
+};
+const getPathDepth = (path) => {
+    return Math.max(0, normalizeArchivePath(path).split('/').length - 1);
+};
+const createEntryView = (source) => {
+    const path = normalizeArchivePath(source.path);
+    const name = getPathName(path);
+    return {
+        id: path,
+        path,
+        name,
+        extension: getArchiveEntryExtension(name),
+        size: source.size,
+        lastModified: source.lastModified,
+        depth: getPathDepth(path),
+        previewable: isPreviewableArchiveEntry(name),
+        compressedFile: {
+            name,
+            size: source.size,
+            lastModified: source.lastModified,
+            async extract() {
+                const buffer = await source.load();
+                return new File([buffer], name, {
+                    type: 'application/octet-stream',
+                    lastModified: source.lastModified || Date.now(),
+                });
+            },
+        },
+    };
+};
+const parseOctal = (bytes, start, length) => {
+    const text = new TextDecoder('ascii')
+        .decode(bytes.slice(start, start + length))
+        .replace(/\0.*$/, '')
+        .trim();
+    return text ? Number.parseInt(text, 8) || 0 : 0;
+};
+const readTarName = (bytes, offset) => {
+    const decoder = new TextDecoder('utf-8');
+    const name = decoder.decode(bytes.slice(offset, offset + 100)).replace(/\0.*$/, '');
+    const prefix = decoder.decode(bytes.slice(offset + 345, offset + 500)).replace(/\0.*$/, '');
+    return normalizeArchivePath(prefix ? `${prefix}/${name}` : name);
+};
+const parseTarEntries = (bytes) => {
+    const entries = [];
+    let offset = 0;
+    while (offset + TAR_BLOCK_SIZE <= bytes.length) {
+        const header = bytes.slice(offset, offset + TAR_BLOCK_SIZE);
+        if (header.every(value => value === 0)) {
+            break;
+        }
+        const path = readTarName(bytes, offset);
+        const size = parseOctal(bytes, offset + 124, 12);
+        const typeFlag = String.fromCharCode(bytes[offset + 156] || 0);
+        const dataOffset = offset + TAR_BLOCK_SIZE;
+        const nextOffset = dataOffset + Math.ceil(size / TAR_BLOCK_SIZE) * TAR_BLOCK_SIZE;
+        if (path && typeFlag !== '5') {
+            const fileBytes = bytes.slice(dataOffset, dataOffset + size);
+            entries.push(createEntryView({
+                path,
+                size,
+                load: async () => toArrayBuffer(fileBytes),
+            }));
+        }
+        offset = nextOffset;
+    }
+    return entries;
+};
+const getArchiveExtension = (filename) => {
+    const lower = filename.toLowerCase();
+    if (lower.endsWith('.tar.gz') || lower.endsWith('.tgz')) {
+        return 'tgz';
+    }
+    return getArchiveEntryExtension(filename);
+};
+const getGzipEntryName = (filename) => {
+    const lower = filename.toLowerCase();
+    if (lower.endsWith('.gzip')) {
+        return filename.slice(0, -5) || 'archive';
+    }
+    if (lower.endsWith('.gz')) {
+        return filename.slice(0, -3) || 'archive';
+    }
+    return `${filename || 'archive'}.bin`;
+};
+const loadZipEntries = async (data) => {
+    const { default: JSZip } = await import('jszip');
+    const zip = await JSZip.loadAsync(data);
+    const entries = [];
+    zip.forEach((relativePath, file) => {
+        var _a, _b;
+        if (file.dir) {
+            return;
+        }
+        const metadata = file;
+        const normalizedPath = normalizeArchivePath(relativePath);
+        entries.push(createEntryView({
+            path: normalizedPath,
+            size: ((_a = metadata._data) === null || _a === void 0 ? void 0 : _a.uncompressedSize) || 0,
+            lastModified: (_b = file.date) === null || _b === void 0 ? void 0 : _b.getTime(),
+            load: async () => file.async('arraybuffer'),
+        }));
+    });
+    return entries;
+};
+const loadTarEntries = async (data, filename, extension) => {
+    const source = new Uint8Array(data);
+    const bytes = extension === 'tar'
+        ? source
+        : await decompressBytes(source, 'gzip');
+    if (!bytes) {
+        return null;
+    }
+    if (extension === 'gz' || extension === 'gzip') {
+        const lower = filename.toLowerCase();
+        const isTarGz = lower.endsWith('.tar.gz') || lower.endsWith('.tgz');
+        if (!isTarGz) {
+            const name = getGzipEntryName(filename);
+            return [createEntryView({
+                    path: name,
+                    size: bytes.byteLength,
+                    load: async () => toArrayBuffer(bytes),
+                })];
+        }
+    }
+    return parseTarEntries(bytes);
+};
+/**
+ * Worker fallback for constrained browsers, temporary local servers, and
+ * mobile WebViews. The main libarchive path still covers broader formats;
+ * this covers common ZIP/TAR/GZIP archives without an extra static Worker.
+ */
+export const loadArchiveEntriesWithoutWorker = async (data, filename) => {
+    const extension = getArchiveExtension(filename);
+    if (ZIP_LIKE_EXTENSIONS.has(extension)) {
+        return loadZipEntries(data);
+    }
+    if (TAR_LIKE_EXTENSIONS.has(extension)) {
+        return loadTarEntries(data, filename, extension);
+    }
+    return null;
+};

package/dist/archiveShared.d.ts

@@ -0,0 +1,23 @@
+export declare const ARCHIVE_PREVIEWABLE_EXTENSIONS: readonly string[];
+export interface ArchiveEntryView {
+    id: string;
+    path: string;
+    name: string;
+    extension: string;
+    size: number;
+    lastModified?: number;
+    depth: number;
+    previewable: boolean;
+    compressedFile: {
+        name: string;
+        size: number;
+        lastModified?: number;
+        extract(): Promise<File>;
+    };
+}
+export declare const getArchiveEntryExtension: (name: string) => string;
+export declare const isArchiveExtension: (extension: string) => boolean;
+export declare const isPreviewableArchiveEntry: (name: string) => boolean;
+export declare const formatArchiveBytes: (value: number) => string;
+export declare const flattenArchiveObject: (input: Record<string, unknown>, prefix?: string) => ArchiveEntryView[];
+export declare const createArchiveCacheKey: (archiveName: string, archiveSize: number, entry: ArchiveEntryView) => string;

package/dist/archiveShared.js

@@ -0,0 +1,71 @@
+import { ARCHIVE_EXTENSIONS, DEFAULT_SUPPORTED_EXTENSIONS, } from '@file-viewer/core';
+export const ARCHIVE_PREVIEWABLE_EXTENSIONS = DEFAULT_SUPPORTED_EXTENSIONS;
+export const getArchiveEntryExtension = (name) => {
+    const clean = name.split(/[?#]/)[0] || name;
+    const dot = clean.lastIndexOf('.');
+    return dot === -1 ? '' : clean.slice(dot + 1).toLowerCase();
+};
+export const isArchiveExtension = (extension) => (ARCHIVE_EXTENSIONS.includes(extension.toLowerCase()));
+export const isPreviewableArchiveEntry = (name) => {
+    const extension = getArchiveEntryExtension(name);
+    return ARCHIVE_PREVIEWABLE_EXTENSIONS.includes(extension);
+};
+export const formatArchiveBytes = (value) => {
+    if (!Number.isFinite(value) || value < 0) {
+        return '-';
+    }
+    if (value < 1024) {
+        return `${value} B`;
+    }
+    const units = ['KB', 'MB', 'GB'];
+    let next = value / 1024;
+    for (const unit of units) {
+        if (next < 1024 || unit === units[units.length - 1]) {
+            return `${next.toFixed(next < 10 ? 1 : 0)} ${unit}`;
+        }
+        next /= 1024;
+    }
+    return `${value} B`;
+};
+const isCompressedFile = (value) => {
+    return typeof value === 'object' &&
+        value !== null &&
+        'extract' in value &&
+        typeof value.extract === 'function';
+};
+export const flattenArchiveObject = (input, prefix = '') => {
+    const entries = [];
+    Object.entries(input).forEach(([key, value]) => {
+        const path = prefix ? `${prefix}/${key}` : key;
+        if (isCompressedFile(value)) {
+            const name = value.name || key;
+            const extension = getArchiveEntryExtension(name);
+            entries.push({
+                id: path,
+                path,
+                name,
+                extension,
+                size: value.size || 0,
+                lastModified: value.lastModified,
+                depth: path.split('/').length - 1,
+                previewable: isPreviewableArchiveEntry(name),
+                compressedFile: value,
+            });
+            return;
+        }
+        if (value && typeof value === 'object') {
+            entries.push(...flattenArchiveObject(value, path));
+        }
+    });
+    return entries;
+};
+export const createArchiveCacheKey = (archiveName, archiveSize, entry) => {
+    return [
+        'archive-entry',
+        archiveName || 'archive',
+        archiveSize,
+        entry.path,
+        entry.size,
+        entry.lastModified || 0,
+    ].join(':');
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import { type FileRenderHandler, type FileViewerRenderedInstance, type FileViewerRendererPlugin, type RendererDefinition } from '@file-viewer/core';
+export declare const archiveRendererDefinition: RendererDefinition;
+export declare const renderFileViewerArchive: FileRenderHandler<FileViewerRenderedInstance, HTMLDivElement>;
+export declare const archiveRenderer: FileViewerRendererPlugin<FileRenderHandler<FileViewerRenderedInstance, HTMLDivElement>>;
+export default archiveRenderer;

package/dist/index.js

@@ -0,0 +1,17 @@
+import { DEFAULT_RENDERER_DEFINITIONS, } from '@file-viewer/core';
+const archiveDefinition = DEFAULT_RENDERER_DEFINITIONS.find(definition => definition.id === 'archive');
+if (!archiveDefinition) {
+    throw new Error('@file-viewer/renderer-archive could not locate the shared archive format definition.');
+}
+export const archiveRendererDefinition = archiveDefinition;
+export const renderFileViewerArchive = (buffer, target, type, context) => import('./archive.js').then(({ default: renderArchive }) => renderArchive(buffer, target, type, context));
+export const archiveRenderer = {
+    id: 'file-viewer-renderer-archive',
+    label: 'Flyfish File Viewer archive renderer',
+    definitions: [archiveRendererDefinition],
+    handlers: [{
+            rendererId: archiveRendererDefinition.id,
+            handler: renderFileViewerArchive,
+        }],
+};
+export default archiveRenderer;

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@file-viewer/renderer-archive",
+  "version": "2.0.11",
+  "private": false,
+  "type": "module",
+  "description": "Standalone archive renderer plugin for Flyfish File Viewer with libarchive worker, ZIP/TAR fallback, IndexedDB cache, and nested previews.",
+  "keywords": [
+    "file-viewer",
+    "renderer",
+    "archive",
+    "zip",
+    "rar",
+    "7z",
+    "tar",
+    "document-preview",
+    "document-viewer",
+    "file-preview",
+    "self-hosted"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "author": {
+    "name": "Wangyu",
+    "email": "wybaby168@gmail.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/flyfish-dev/file-viewer-renderer-archive.git",
+    "directory": "packages/renderers/archive"
+  },
+  "homepage": "https://doc.file-viewer.app/guide/on-demand-renderers",
+  "bugs": {
+    "url": "https://github.com/flyfish-dev/file-viewer-renderer-archive/issues"
+  },
+  "funding": {
+    "type": "individual",
+    "url": "https://dev.flyfish.group/shop"
+  },
+  "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.0.11",
+    "jszip": "^3.10.1",
+    "libarchive.js": "^2.0.2"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.3"
+  },
+  "license": "Apache-2.0",
+  "scripts": {
+    "build": "tsc -b tsconfig.json",
+    "type-check": "tsc -b tsconfig.json"
+  }
+}