@file-viewer/core 2.2.4 → 2.2.5

package/dist/renderers/image.js

@@ -22,13 +22,18 @@ const imageStyle = `
 .image-viewer{position:relative;width:100%;height:100%;overflow:auto;background:var(--file-viewer-render-surface-background,#eef1f4);box-sizing:border-box}
 .image-stage{min-width:100%;min-height:100%;display:flex;align-items:center;justify-content:center;padding:24px;box-sizing:border-box}
 .image-stage img{display:block;width:auto;max-width:none;margin:0 auto;border:0;box-shadow:0 18px 48px rgba(15,23,42,.16);background:#fff;cursor:zoom-in}
-.image-lightbox{position:fixed;inset:0;z-index:2147483000;display:flex;align-items:center;justify-content:center;padding:40px;background:rgba(15,23,42,.88);box-sizing:border-box}
-.image-lightbox[hidden]{display:none}
-.image-lightbox img{display:block;max-width:100%;max-height:100%;object-fit:contain;background:#fff;box-shadow:0 30px 80px rgba(0,0,0,.4);cursor:zoom-out}
-.image-lightbox button{position:absolute;top:20px;right:20px;width:40px;height:40px;border:0;border-radius:999px;background:rgba(255,255,255,.92);color:#172033;font-size:24px;line-height:40px;cursor:pointer;box-shadow:0 12px 28px rgba(0,0,0,.18)}
+.image-stage img:focus-visible{outline:3px solid #2563eb;outline-offset:4px}
+.image-lightbox{position:absolute;inset:0;z-index:40;display:flex;align-items:center;justify-content:center;padding:40px;background:rgba(15,23,42,.9);box-sizing:border-box;opacity:0;visibility:hidden;pointer-events:none;transition:opacity .18s ease,visibility 0s linear .18s}
+.image-lightbox[data-open='true']{opacity:1;visibility:visible;pointer-events:auto;transition-delay:0s}
+.image-lightbox img{display:block;max-width:100%;max-height:100%;object-fit:contain;background:#fff;box-shadow:0 30px 80px rgba(0,0,0,.4);cursor:default;transform:scale(.985);transition:transform .18s ease}
+.image-lightbox[data-open='true'] img{transform:scale(1)}
+.image-lightbox button{position:absolute;top:16px;right:16px;display:grid;width:40px;height:40px;place-items:center;padding:0;border:1px solid rgba(255,255,255,.7);border-radius:999px;background:rgba(255,255,255,.96);color:#172033;font:400 27px/1 Arial,sans-serif;cursor:pointer;box-shadow:0 12px 28px rgba(0,0,0,.24);transition:background-color .14s ease,transform .14s ease}
+.image-lightbox button:hover{background:#fff;transform:scale(1.04)}
+.image-lightbox button:focus-visible{outline:3px solid #60a5fa;outline-offset:2px}
 [data-viewer-theme='dark'] .image-viewer{background:var(--file-viewer-render-surface-background,#101820)}
 @media (prefers-color-scheme:dark){[data-viewer-theme='system'] .image-viewer{background:var(--file-viewer-render-surface-background,#101820)}}
 @media (max-width:767px){.image-stage{padding:12px}.image-lightbox{padding:16px}.image-lightbox button{top:12px;right:12px}}
+@media (prefers-reduced-motion:reduce){.image-lightbox,.image-lightbox img,.image-lightbox button{transition:none}}
 `;
 const createStyle = (documentRef) => {
     const style = documentRef.createElement('style');
@@ -68,35 +73,55 @@ const roundImageScale = (value) => {
 const createLightbox = (documentRef, src, t) => {
     const lightbox = documentRef.createElement('div');
     lightbox.className = 'image-lightbox';
-    lightbox.hidden = true;
+    lightbox.dataset.open = 'false';
     lightbox.setAttribute('role', 'dialog');
     lightbox.setAttribute('aria-modal', 'true');
+    lightbox.setAttribute('aria-hidden', 'true');
     const image = documentRef.createElement('img');
     image.alt = t('image.lightbox.alt');
     image.src = src;
     const closeButton = documentRef.createElement('button');
     closeButton.type = 'button';
     closeButton.setAttribute('aria-label', t('image.lightbox.close'));
-    closeButton.textContent = 'x';
+    closeButton.textContent = '×';
+    let previousFocus = null;
     const close = () => {
-        lightbox.hidden = true;
+        if (lightbox.dataset.open !== 'true')
+            return;
+        lightbox.dataset.open = 'false';
+        lightbox.setAttribute('aria-hidden', 'true');
+        if (previousFocus === null || previousFocus === void 0 ? void 0 : previousFocus.isConnected) {
+            previousFocus.focus({ preventScroll: true });
+        }
+        previousFocus = null;
+    };
+    const onKeyDown = (event) => {
+        if (event.key === 'Escape' && lightbox.dataset.open === 'true') {
+            event.preventDefault();
+            close();
+        }
     };
     closeButton.addEventListener('click', close);
-    image.addEventListener('click', close);
     lightbox.addEventListener('click', event => {
         if (event.target === lightbox) {
             close();
         }
     });
+    documentRef.addEventListener('keydown', onKeyDown);
     lightbox.append(image, closeButton);
     return {
         element: lightbox,
-        open() {
-            lightbox.hidden = false;
+        open(invoker) {
+            previousFocus =
+                invoker ||
+                    (documentRef.activeElement instanceof HTMLElement ? documentRef.activeElement : null);
+            lightbox.dataset.open = 'true';
+            lightbox.setAttribute('aria-hidden', 'false');
+            closeButton.focus({ preventScroll: true });
         },
         destroy() {
             closeButton.removeEventListener('click', close);
-            image.removeEventListener('click', close);
+            documentRef.removeEventListener('keydown', onKeyDown);
             lightbox.remove();
         },
     };
@@ -122,11 +147,21 @@ export default async function renderImage(buffer, target, type, context) {
     const image = documentRef.createElement('img');
     image.alt = t('image.alt');
     image.src = src;
+    image.tabIndex = 0;
+    image.setAttribute('role', 'button');
+    image.setAttribute('aria-haspopup', 'dialog');
     stage.append(image);
     root.append(stage);
     const lightbox = createLightbox(documentRef, src, t);
-    const openLightbox = () => lightbox.open();
+    const openLightbox = () => lightbox.open(image);
+    const openLightboxFromKeyboard = (event) => {
+        if (event.key === 'Enter' || event.key === ' ') {
+            event.preventDefault();
+            lightbox.open(image);
+        }
+    };
     image.addEventListener('click', openLightbox);
+    image.addEventListener('keydown', openLightboxFromKeyboard);
     const getMinScale = () => Math.min(0.1, fitScale || 0.1);
     const clampScale = (value) => {
         const minScale = getMinScale();
@@ -250,6 +285,7 @@ export default async function renderImage(buffer, target, type, context) {
             resizeObserver.disconnect();
             image.removeEventListener('load', updateViewportSize);
             image.removeEventListener('click', openLightbox);
+            image.removeEventListener('keydown', openLightboxFromKeyboard);
             lightbox.destroy();
             target.replaceChildren();
         },

package/dist/source/precheck.d.ts

@@ -0,0 +1,36 @@
+import type { FileViewerFileRef, FileViewerSource } from '../contracts/types';
+export type FileViewerPrecheckStatus = 'ready' | 'invalid' | 'unsupported';
+export type FileViewerPrecheckReason = 'content-valid' | 'content-not-inspected' | 'content-inconclusive' | 'empty-structured-file' | 'signature-mismatch' | 'invalid-package' | 'missing-package-part' | 'unsupported-extension';
+export interface FileViewerPrecheckOptions {
+    /** Filename used when a Blob or ArrayBuffer has no name. */
+    filename?: string;
+    /** Explicit extension, with or without a leading dot. */
+    type?: string;
+    /** Restricts the result to the renderers installed by the host application. */
+    supportedExtensions?: Iterable<string>;
+    /** Maximum ZIP central-directory bytes read from a Blob. Defaults to 8 MiB. */
+    maxPackageMetadataBytes?: number;
+}
+export interface FileViewerPrecheckResult {
+    filename: string;
+    extension: string;
+    rendererId: string | null;
+    supported: boolean;
+    inspected: boolean;
+    /** `null` means the extension is supported but no structural validator exists. */
+    valid: boolean | null;
+    previewable: boolean;
+    status: FileViewerPrecheckStatus;
+    reason: FileViewerPrecheckReason;
+    missingParts: string[];
+}
+type FileViewerPrecheckInput = FileViewerSource | FileViewerFileRef;
+/**
+ * Performs a cheap, renderer-free capability and structure check.
+ *
+ * This intentionally does not promise rendering fidelity. A `ready` result
+ * means the extension is available and any known container/signature checks
+ * passed; the real renderer remains the final authority for malformed content.
+ */
+export declare const precheckFileViewerSource: (input: FileViewerPrecheckInput, options?: FileViewerPrecheckOptions) => Promise<FileViewerPrecheckResult>;
+export {};

package/dist/source/precheck.js

@@ -0,0 +1,250 @@
+import { DEFAULT_RENDERER_DEFINITIONS, DEFAULT_SUPPORTED_EXTENSIONS } from '../registry/formats.js';
+import { getExtension, normalizeFileExtension, normalizeFilename, normalizeSource, } from './index.js';
+const DEFAULT_MAX_PACKAGE_METADATA_BYTES = 8 * 1024 * 1024;
+const ZIP_LOCAL_SIGNATURE = 0x04034b50;
+const ZIP_CENTRAL_SIGNATURE = 0x02014b50;
+const ZIP_END_SIGNATURE = 0x06054b50;
+const ZIP64_SENTINEL = 0xffffffff;
+const OLE_SIGNATURE = [0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1];
+const OPEN_XML_REQUIRED_PARTS = {
+    docx: ['[content_types].xml', 'word/document.xml'],
+    docm: ['[content_types].xml', 'word/document.xml'],
+    dotx: ['[content_types].xml', 'word/document.xml'],
+    dotm: ['[content_types].xml', 'word/document.xml'],
+    xlsx: ['[content_types].xml', 'xl/workbook.xml'],
+    xltx: ['[content_types].xml', 'xl/workbook.xml'],
+    xlsm: ['[content_types].xml', 'xl/workbook.xml'],
+    xltm: ['[content_types].xml', 'xl/workbook.xml'],
+    xlsb: ['[content_types].xml', 'xl/workbook.bin'],
+    pptx: ['[content_types].xml', 'ppt/presentation.xml'],
+    pptm: ['[content_types].xml', 'ppt/presentation.xml'],
+    potx: ['[content_types].xml', 'ppt/presentation.xml'],
+    potm: ['[content_types].xml', 'ppt/presentation.xml'],
+    ppsx: ['[content_types].xml', 'ppt/presentation.xml'],
+    ppsm: ['[content_types].xml', 'ppt/presentation.xml'],
+    odt: ['content.xml'],
+    ods: ['content.xml'],
+    odp: ['content.xml'],
+    ofd: ['ofd.xml'],
+    numbers: ['index/document.iwa'],
+    epub: ['meta-inf/container.xml'],
+    xps: ['[content_types].xml'],
+    dwfx: ['[content_types].xml'],
+};
+const ZIP_EXTENSIONS = new Set([
+    ...Object.keys(OPEN_XML_REQUIRED_PARTS),
+    'zip', 'zipx', 'jar', 'war', 'ear', 'apk', 'cbz',
+]);
+const OLE_EXTENSIONS = new Set(['doc', 'dot', 'xls', 'xlt', 'ppt', 'msg']);
+const TEXT_DECODER = new TextDecoder('utf-8');
+const isArrayBuffer = (value) => value instanceof ArrayBuffer;
+const isBlob = (value) => (typeof Blob !== 'undefined' && value instanceof Blob);
+const toSource = (input, options) => {
+    if (isArrayBuffer(input)) {
+        return { buffer: input, filename: options.filename, type: options.type };
+    }
+    if (isBlob(input)) {
+        return { file: input, filename: options.filename, type: options.type };
+    }
+    return {
+        ...input,
+        filename: options.filename || input.filename,
+        type: options.type || input.type,
+    };
+};
+const startsWithBytes = (bytes, expected) => (expected.every((value, index) => bytes[index] === value));
+const findEndOfCentralDirectory = (bytes) => {
+    for (let offset = bytes.byteLength - 22; offset >= 0; offset -= 1) {
+        if (bytes[offset] === 0x50 &&
+            bytes[offset + 1] === 0x4b &&
+            bytes[offset + 2] === 0x05 &&
+            bytes[offset + 3] === 0x06) {
+            return offset;
+        }
+    }
+    return -1;
+};
+const collectCentralDirectoryEntries = (bytes) => {
+    const entries = new Set();
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    let offset = 0;
+    while (offset + 46 <= bytes.byteLength) {
+        if (view.getUint32(offset, true) !== ZIP_CENTRAL_SIGNATURE) {
+            break;
+        }
+        const filenameLength = view.getUint16(offset + 28, true);
+        const extraLength = view.getUint16(offset + 30, true);
+        const commentLength = view.getUint16(offset + 32, true);
+        const end = offset + 46 + filenameLength;
+        if (end > bytes.byteLength) {
+            return { entries, complete: false };
+        }
+        entries.add(TEXT_DECODER.decode(bytes.subarray(offset + 46, end)).replace(/^\/+/, '').toLowerCase());
+        offset = end + extraLength + commentLength;
+    }
+    return { entries, complete: offset === bytes.byteLength };
+};
+const inspectZipBuffer = (buffer) => {
+    const bytes = new Uint8Array(buffer);
+    if (bytes.byteLength < 22) {
+        return { signatureValid: false, complete: true, entries: new Set() };
+    }
+    const view = new DataView(buffer);
+    const firstSignature = view.getUint32(0, true);
+    if (firstSignature !== ZIP_LOCAL_SIGNATURE && firstSignature !== ZIP_END_SIGNATURE) {
+        return { signatureValid: false, complete: true, entries: new Set() };
+    }
+    const endOffset = findEndOfCentralDirectory(bytes);
+    if (endOffset < 0) {
+        return { signatureValid: true, complete: false, entries: new Set() };
+    }
+    const centralSize = view.getUint32(endOffset + 12, true);
+    const centralOffset = view.getUint32(endOffset + 16, true);
+    if (centralSize === ZIP64_SENTINEL || centralOffset === ZIP64_SENTINEL) {
+        return { signatureValid: true, complete: false, entries: new Set() };
+    }
+    if (centralOffset + centralSize > bytes.byteLength) {
+        return { signatureValid: true, complete: false, entries: new Set() };
+    }
+    const result = collectCentralDirectoryEntries(bytes.subarray(centralOffset, centralOffset + centralSize));
+    return { signatureValid: true, complete: result.complete, entries: result.entries };
+};
+const inspectZipBlob = async (blob, maxPackageMetadataBytes) => {
+    if (blob.size < 22) {
+        return { signatureValid: false, complete: true, entries: new Set() };
+    }
+    const prefix = new Uint8Array(await blob.slice(0, 4).arrayBuffer());
+    const prefixView = new DataView(prefix.buffer, prefix.byteOffset, prefix.byteLength);
+    const firstSignature = prefixView.getUint32(0, true);
+    if (firstSignature !== ZIP_LOCAL_SIGNATURE && firstSignature !== ZIP_END_SIGNATURE) {
+        return { signatureValid: false, complete: true, entries: new Set() };
+    }
+    const tailStart = Math.max(0, blob.size - 65557);
+    const tail = new Uint8Array(await blob.slice(tailStart).arrayBuffer());
+    const endOffset = findEndOfCentralDirectory(tail);
+    if (endOffset < 0) {
+        return { signatureValid: true, complete: false, entries: new Set() };
+    }
+    const tailView = new DataView(tail.buffer, tail.byteOffset, tail.byteLength);
+    const centralSize = tailView.getUint32(endOffset + 12, true);
+    const centralOffset = tailView.getUint32(endOffset + 16, true);
+    if (centralSize === ZIP64_SENTINEL ||
+        centralOffset === ZIP64_SENTINEL ||
+        centralSize > maxPackageMetadataBytes ||
+        centralOffset + centralSize > blob.size) {
+        return { signatureValid: true, complete: false, entries: new Set() };
+    }
+    const central = new Uint8Array(await blob.slice(centralOffset, centralOffset + centralSize).arrayBuffer());
+    const result = collectCentralDirectoryEntries(central);
+    return { signatureValid: true, complete: result.complete, entries: result.entries };
+};
+const inspectZip = async (source, maxPackageMetadataBytes) => {
+    if (source.buffer) {
+        return inspectZipBuffer(source.buffer);
+    }
+    if (source.file) {
+        return inspectZipBlob(source.file, maxPackageMetadataBytes);
+    }
+    return null;
+};
+const readPrefix = async (source, byteLength = 1024) => {
+    if (source.buffer) {
+        return new Uint8Array(source.buffer, 0, Math.min(source.buffer.byteLength, byteLength));
+    }
+    if (source.file) {
+        return new Uint8Array(await source.file.slice(0, byteLength).arrayBuffer());
+    }
+    return null;
+};
+const inspectStructuredContent = async (source, extension, maxPackageMetadataBytes) => {
+    var _a, _b, _c;
+    const size = (_b = (_a = source.buffer) === null || _a === void 0 ? void 0 : _a.byteLength) !== null && _b !== void 0 ? _b : (_c = source.file) === null || _c === void 0 ? void 0 : _c.size;
+    if (size === 0 && (ZIP_EXTENSIONS.has(extension) || OLE_EXTENSIONS.has(extension) || extension === 'pdf')) {
+        return { inspected: true, valid: false, reason: 'empty-structured-file' };
+    }
+    if (ZIP_EXTENSIONS.has(extension)) {
+        const zip = await inspectZip(source, maxPackageMetadataBytes);
+        if (!zip) {
+            return { inspected: false, valid: null, reason: 'content-not-inspected' };
+        }
+        if (!zip.signatureValid) {
+            return { inspected: true, valid: false, reason: 'signature-mismatch' };
+        }
+        const required = OPEN_XML_REQUIRED_PARTS[extension] || [];
+        if (!zip.complete) {
+            return { inspected: true, valid: null, reason: 'content-inconclusive' };
+        }
+        const missingParts = required.filter(part => !zip.entries.has(part));
+        if (missingParts.length) {
+            return { inspected: true, valid: false, reason: 'missing-package-part', missingParts };
+        }
+        return { inspected: true, valid: true, reason: 'content-valid' };
+    }
+    const prefix = await readPrefix(source);
+    if (!prefix) {
+        return { inspected: false, valid: null, reason: 'content-not-inspected' };
+    }
+    if (OLE_EXTENSIONS.has(extension)) {
+        return startsWithBytes(prefix, OLE_SIGNATURE)
+            ? { inspected: true, valid: true, reason: 'content-valid' }
+            : { inspected: true, valid: false, reason: 'signature-mismatch' };
+    }
+    if (extension === 'pdf') {
+        const header = TEXT_DECODER.decode(prefix);
+        return /%PDF-\d\.\d/.test(header)
+            ? { inspected: true, valid: true, reason: 'content-valid' }
+            : { inspected: true, valid: false, reason: 'signature-mismatch' };
+    }
+    if (extension === 'rtf') {
+        const header = TEXT_DECODER.decode(prefix);
+        return /^\s*\{\\rtf\d/.test(header)
+            ? { inspected: true, valid: true, reason: 'content-valid' }
+            : { inspected: true, valid: false, reason: 'signature-mismatch' };
+    }
+    return { inspected: false, valid: null, reason: 'content-not-inspected' };
+};
+/**
+ * Performs a cheap, renderer-free capability and structure check.
+ *
+ * This intentionally does not promise rendering fidelity. A `ready` result
+ * means the extension is available and any known container/signature checks
+ * passed; the real renderer remains the final authority for malformed content.
+ */
+export const precheckFileViewerSource = async (input, options = {}) => {
+    var _a;
+    const source = toSource(input, options);
+    const normalized = normalizeSource(source);
+    const extension = normalizeFileExtension(options.type || normalized.extension || getExtension(options.filename || normalized.filename));
+    const filename = normalizeFilename(options.filename || normalized.filename);
+    const supportedExtensions = new Set(Array.from(options.supportedExtensions || DEFAULT_SUPPORTED_EXTENSIONS, normalizeFileExtension));
+    const supported = supportedExtensions.has(extension);
+    const rendererId = ((_a = DEFAULT_RENDERER_DEFINITIONS.find(definition => definition.extensions.some(candidate => normalizeFileExtension(candidate) === extension))) === null || _a === void 0 ? void 0 : _a.id) || null;
+    if (!supported) {
+        return {
+            filename,
+            extension,
+            rendererId,
+            supported: false,
+            inspected: false,
+            valid: null,
+            previewable: false,
+            status: 'unsupported',
+            reason: 'unsupported-extension',
+            missingParts: [],
+        };
+    }
+    const inspection = await inspectStructuredContent(source, extension, Math.max(64 * 1024, options.maxPackageMetadataBytes || DEFAULT_MAX_PACKAGE_METADATA_BYTES));
+    const valid = inspection.valid;
+    return {
+        filename,
+        extension,
+        rendererId,
+        supported: true,
+        inspected: inspection.inspected,
+        valid,
+        previewable: valid !== false,
+        status: valid === false ? 'invalid' : 'ready',
+        reason: inspection.reason,
+        missingParts: inspection.missingParts || [],
+    };
+};

package/dist/viewer/createViewer.js

@@ -636,13 +636,14 @@ export const createViewer = (container, createOptions = {}) => {
             });
         },
         async printWithMask(printOptions = {}) {
-            var _a, _b, _c, _d;
+            var _a, _b, _c, _d, _e;
             const result = await openFileViewerPrintMaskDesignerAsync({
                 root: container,
                 pages: (_b = (_a = renderSurfaceState.exportAdapter) === null || _a === void 0 ? void 0 : _a.getPrintMaskPages) === null || _b === void 0 ? void 0 : _b.call(_a),
                 i18n: options,
                 color: (_c = printOptions.mask) === null || _c === void 0 ? void 0 : _c.color,
                 initialRegions: (_d = printOptions.mask) === null || _d === void 0 ? void 0 : _d.regions,
+                initialStamps: (_e = printOptions.mask) === null || _e === void 0 ? void 0 : _e.stamps,
             });
             if (!(result === null || result === void 0 ? void 0 : result.mask)) {
                 return;

package/dist/viewer/operations.js

@@ -262,7 +262,7 @@ export const createFileViewerOperationActionHandlers = ({ getBuffer, getFile, ge
             }
         },
         async printWithMask(options = {}) {
-            var _a, _b, _c, _d, _e, _f, _g;
+            var _a, _b, _c, _d, _e, _f, _g, _h;
             try {
                 const source = getRenderedSource();
                 if (!source) {
@@ -276,6 +276,7 @@ export const createFileViewerOperationActionHandlers = ({ getBuffer, getFile, ge
                     i18n: resolveI18n(),
                     color: (_c = options.mask) === null || _c === void 0 ? void 0 : _c.color,
                     initialRegions: (_d = options.mask) === null || _d === void 0 ? void 0 : _d.regions,
+                    initialStamps: (_e = options.mask) === null || _e === void 0 ? void 0 : _e.stamps,
                 });
                 if (!(result === null || result === void 0 ? void 0 : result.mask)) {
                     return undefined;
@@ -283,9 +284,9 @@ export const createFileViewerOperationActionHandlers = ({ getBuffer, getFile, ge
                 return await executeFileViewerPrintOperation({
                     ...getRenderedOperationInput(),
                     ...options,
-                    watermarkInlineStyle: (_f = (_e = options.watermarkInlineStyle) !== null && _e !== void 0 ? _e : getWatermarkInlineStyle === null || getWatermarkInlineStyle === void 0 ? void 0 : getWatermarkInlineStyle()) !== null && _f !== void 0 ? _f : undefined,
+                    watermarkInlineStyle: (_g = (_f = options.watermarkInlineStyle) !== null && _f !== void 0 ? _f : getWatermarkInlineStyle === null || getWatermarkInlineStyle === void 0 ? void 0 : getWatermarkInlineStyle()) !== null && _g !== void 0 ? _g : undefined,
                     mask: result.mask,
-                    printAvailable: (_g = getPrintAvailable === null || getPrintAvailable === void 0 ? void 0 : getPrintAvailable()) !== null && _g !== void 0 ? _g : true,
+                    printAvailable: (_h = getPrintAvailable === null || getPrintAvailable === void 0 ? void 0 : getPrintAvailable()) !== null && _h !== void 0 ? _h : true,
                 });
             }
             catch (error) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@file-viewer/core",
-  "version": "2.2.4",
+  "version": "2.2.5",
   "private": false,
   "type": "module",
   "description": "Framework-neutral modular TypeScript core for File Viewer renderer orchestration, lifecycle APIs, search, zoom, print, and export",