web-doc 0.3.0

package/dist/assets/pdfjs/wasm/quickjs-eval.js

@@ -0,0 +1,16 @@
+/* THIS FILE IS GENERATED - DO NOT EDIT */
+async function QuickJS(moduleArg={}){var moduleRtn;var e=moduleArg,aa=import.meta.url,h="",m;try{h=(new URL(".",aa)).href}catch{}m=async a=>{a=await fetch(a,{credentials:"same-origin"});if(a.ok)return a.arrayBuffer();throw Error(a.status+" : "+a.url);};var q=console.error.bind(console),r,t=!1,u,v,w,x=!1;function y(){var a=z.buffer;A=new Int8Array(a);new Int16Array(a);B=new Uint8Array(a);new Uint16Array(a);C=new Int32Array(a);D=new Uint32Array(a);new Float32Array(a);new Float64Array(a);new BigInt64Array(a);new BigUint64Array(a)}
+function E(a){e.onAbort?.(a);a=`Aborted(${a})`;q(a);t=!0;a=new WebAssembly.RuntimeError(a+". Build with -sASSERTIONS for more info.");w?.(a);throw a;}var F;async function ba(a){if(!r)try{var b=await m(a);return new Uint8Array(b)}catch{}if(a==F&&r)a=new Uint8Array(r);else throw"both async and sync fetching of the wasm failed";return a}async function ca(a,b){try{var c=await ba(a);return await WebAssembly.instantiate(c,b)}catch(d){q(`failed to asynchronously prepare wasm: ${d}`),E(d)}}
+async function da(a){var b=F;if(!r)try{var c=fetch(b,{credentials:"same-origin"});return await WebAssembly.instantiateStreaming(c,a)}catch(d){q(`wasm streaming compile failed: ${d}`),q("falling back to ArrayBuffer instantiation")}return ca(b,a)}class G{name="ExitStatus";constructor(a){this.message=`Program terminated with exit(${a})`;this.status=a}}
+var C,A,D,B,H=a=>{for(;a.length>0;)a.shift()(e)},I=[],J=[],ea=()=>{var a=e.preRun.shift();J.push(a)},K=!0,L=0,fa=[0,31,60,91,121,152,182,213,244,274,305,335],ha=[0,31,59,90,120,151,181,212,243,273,304,334],M={},N=a=>{if(!(a instanceof G||a=="unwind"))throw a;},O=a=>{u=a;K||L>0||(e.onExit?.(a),t=!0);throw new G(a);},ia=a=>{if(!t)try{a()}catch(b){N(b)}finally{if(!(K||L>0))try{u=a=u,O(a)}catch(b){N(b)}}},P=(a,b,c)=>{var d=B;if(c>0){c=b+c-1;for(var g=0;g<a.length;++g){var f=a.codePointAt(g);if(f<=127){if(b>=
+c)break;d[b++]=f}else if(f<=2047){if(b+1>=c)break;d[b++]=192|f>>6;d[b++]=128|f&63}else if(f<=65535){if(b+2>=c)break;d[b++]=224|f>>12;d[b++]=128|f>>6&63;d[b++]=128|f&63}else{if(b+3>=c)break;d[b++]=240|f>>18;d[b++]=128|f>>12&63;d[b++]=128|f>>6&63;d[b++]=128|f&63;g++}}d[b]=0}},ja=new TextDecoder,Q=a=>{if(a){for(var b=a,c=B,d=b+void 0;c[b]&&!(b>=d);)++b;a=ja.decode(B.subarray(a,b))}else a="";return a},R=a=>{for(var b=0,c=0;c<a.length;++c){var d=a.charCodeAt(c);d<=127?b++:d<=2047?b+=2:d>=55296&&d<=57343?
+(b+=4,++c):b+=3}return b},T=a=>{var b=R(a)+1,c=S(b);c&&P(a,c,b);return c};function U(){}var la=(a,b,c,d)=>{var g={string:k=>{var n=0;if(k!==null&&k!==void 0&&k!==0){n=R(k)+1;var X=V(n);P(k,X,n);n=X}return n},array:k=>{var n=V(k.length);A.set(k,n);return n}};a=e["_"+a];var f=[],p=0;if(d)for(var l=0;l<d.length;l++){var Y=g[c[l]];Y?(p===0&&(p=W()),f[l]=Y(d[l])):f[l]=d[l]}c=a(...f);return c=function(k){p!==0&&ka(p);return b==="string"?Q(k):b==="boolean"?!!k:k}(c)};
+U=(a,b,c)=>{a=Q(a);b=b!==null?JSON.parse(Q(b)):[];try{let d=e.externalCall(a,b);return d?T(d):null}catch(d){return e.HEAPU8[c]=1,T(d.message)}};e.noExitRuntime&&(K=e.noExitRuntime);e.printErr&&(q=e.printErr);e.wasmBinary&&(r=e.wasmBinary);if(e.preInit)for(typeof e.preInit=="function"&&(e.preInit=[e.preInit]);e.preInit.length>0;)e.preInit.shift()();e.ccall=la;e.cwrap=(a,b,c,d)=>{var g=!c||c.every(f=>f==="number"||f==="boolean");return b!=="string"&&g&&!d?e["_"+a]:(...f)=>la(a,b,c,f,d)};
+e.stringToNewUTF8=T;
+var S,ma,ka,V,W,z,na={e:()=>E(""),a:()=>{K=!1;L=0},b:function(a,b){a=a<-9007199254740992||a>9007199254740992?NaN:Number(a);a=new Date(a*1E3);C[b>>2]=a.getSeconds();C[b+4>>2]=a.getMinutes();C[b+8>>2]=a.getHours();C[b+12>>2]=a.getDate();C[b+16>>2]=a.getMonth();C[b+20>>2]=a.getFullYear()-1900;C[b+24>>2]=a.getDay();var c=a.getFullYear();C[b+28>>2]=(c%4!==0||c%100===0&&c%400!==0?ha:fa)[a.getMonth()]+a.getDate()-1|0;C[b+36>>2]=-(a.getTimezoneOffset()*60);c=(new Date(a.getFullYear(),6,1)).getTimezoneOffset();
+var d=(new Date(a.getFullYear(),0,1)).getTimezoneOffset();C[b+32>>2]=(c!=d&&a.getTimezoneOffset()==Math.min(d,c))|0},i:(a,b)=>{M[a]&&(clearTimeout(M[a].id),delete M[a]);if(!b)return 0;var c=setTimeout(()=>{delete M[a];ia(()=>ma(a,performance.now()))},b);M[a]={id:c,A:b};return 0},c:(a,b,c,d)=>{var g=(new Date).getFullYear(),f=(new Date(g,0,1)).getTimezoneOffset();g=(new Date(g,6,1)).getTimezoneOffset();D[a>>2]=Math.max(f,g)*60;C[b>>2]=Number(f!=g);b=p=>{var l=Math.abs(p);return`UTC${p>=0?"-":"+"}${String(Math.floor(l/
+60)).padStart(2,"0")}${String(l%60).padStart(2,"0")}`};a=b(f);b=b(g);g<f?(P(a,c,17),P(b,d,17)):(P(a,d,17),P(b,c,17))},g:U,f:function(a,b){a=Q(a);try{var c=window.JSON.parse(a)}catch(d){c=a}b!==0?window.alert(a):window.console.log("DUMP",c)},d:()=>Date.now(),j:a=>{var b=B.length;a>>>=0;if(a>2147483648)return!1;for(var c=1;c<=4;c*=2){var d=b*(1+.2/c);d=Math.min(d,a+100663296);a:{d=(Math.min(2147483648,Math.ceil(Math.max(a,d)/65536)*65536)-z.buffer.byteLength+65535)/65536|0;try{z.grow(d);y();var g=1;
+break a}catch(f){}g=void 0}if(g)return!0}return!1},m:function(a){a=Q(a);window.console.log(a)},h:function(a){a=Q(a);return Date.parse(a)},l:function(a,b,c,d){a=Q(a);b=Q(b);c=Q(c);c=`Quickjs -- ${a}: ${b}\n${c}`;d!==0?window.alert(c):window.console.error(c)},k:O},Z;
+Z=await (async function(){function a(c){c=Z=c.exports;e._evalInSandbox=c.p;e._nukeSandbox=c.q;e._init=c.r;e._commFun=c.s;e._dumpMemoryUse=c.t;S=c.u;e._free=c.v;ma=c.w;ka=c.x;V=c.y;W=c.z;z=c.n;y();return Z}var b={a:na};if(e.instantiateWasm)return new Promise(c=>{e.instantiateWasm(b,(d,g)=>{c(a(d,g))})});F??=e.locateFile?e.locateFile?e.locateFile("quickjs-eval.wasm",h):h+"quickjs-eval.wasm":(new URL("quickjs-eval.wasm",import.meta.url)).href;return function(c){return a(c.instance)}(await da(b))}());
+(function(){function a(){e.calledRun=!0;if(!t){x=!0;Z.o();v?.(e);e.onRuntimeInitialized?.();if(e.postRun)for(typeof e.postRun=="function"&&(e.postRun=[e.postRun]);e.postRun.length;){var b=e.postRun.shift();I.push(b)}H(I)}}if(e.preRun)for(typeof e.preRun=="function"&&(e.preRun=[e.preRun]);e.preRun.length;)ea();H(J);e.setStatus?(e.setStatus("Running..."),setTimeout(()=>{setTimeout(()=>e.setStatus(""),1);a()},1)):a()})();x?moduleRtn=e:moduleRtn=new Promise((a,b)=>{v=a;w=b});
+;return moduleRtn}export default QuickJS;

package/dist/client.d.ts

@@ -0,0 +1,20 @@
+import type { DocumentAdapter, ResourceLimits, ViewerClientOptions, ViewerFetch, ViewerLogger, ViewerOptions } from "./contracts.js";
+import { AdapterRegistry } from "./registry.js";
+import { DocumentViewer } from "./viewer.js";
+import { FontManager } from "./fonts.js";
+import { RenderScheduler } from "./render-scheduler.js";
+export declare class ViewerClient {
+    #private;
+    readonly registry: AdapterRegistry;
+    readonly fetch: ViewerFetch;
+    readonly logger?: ViewerLogger;
+    readonly assetBaseUrl?: URL;
+    readonly limits: ResourceLimits;
+    readonly fonts: FontManager;
+    readonly renderScheduler: RenderScheduler;
+    static create(options?: ViewerClientOptions): ViewerClient;
+    constructor(options?: ViewerClientOptions);
+    createViewer(options?: ViewerOptions): DocumentViewer;
+    registerAdapter(adapter: DocumentAdapter): () => void;
+    destroy(): Promise<void>;
+}

package/dist/client.js

@@ -0,0 +1,82 @@
+import { ViewerError } from "./errors.js";
+import { defaultResourceLimits, resolveLimits } from "./limits.js";
+import { AdapterRegistry } from "./registry.js";
+import { DocumentViewer } from "./viewer.js";
+import { createOfficeAdapter } from "./adapters/office.js";
+import { createPdfAdapter } from "./adapters/pdf.js";
+import { createImageAdapter } from "./adapters/image.js";
+import { createCsvAdapter } from "./adapters/csv.js";
+import { createSvgAdapter } from "./adapters/svg.js";
+import { FontManager } from "./fonts.js";
+import { RenderScheduler } from "./render-scheduler.js";
+export class ViewerClient {
+    registry;
+    fetch;
+    logger;
+    assetBaseUrl;
+    limits;
+    fonts;
+    renderScheduler;
+    #viewers = new Set();
+    #destroyed = false;
+    static create(options = {}) {
+        return new ViewerClient(options);
+    }
+    constructor(options = {}) {
+        this.registry = new AdapterRegistry(options.adapters ?? [
+            createOfficeAdapter(),
+            createPdfAdapter(),
+            createImageAdapter(),
+            createCsvAdapter(),
+            createSvgAdapter(),
+        ]);
+        this.fetch = options.fetch ?? globalThis.fetch?.bind(globalThis);
+        if (!this.fetch)
+            throw new ViewerError("network-error", "No global fetch implementation is available; supply options.fetch");
+        if (options.logger)
+            this.logger = options.logger;
+        if (options.assetBaseUrl)
+            this.assetBaseUrl = new URL(options.assetBaseUrl, globalThis.location?.href ?? "http://localhost/");
+        this.limits = resolveLimits(defaultResourceLimits, options.limits);
+        this.fonts = new FontManager({
+            fetch: this.fetch,
+            ...(this.assetBaseUrl ? { assetBaseUrl: this.assetBaseUrl } : {}),
+            ...(options.fontPolicy ? { policy: options.fontPolicy } : {}),
+            ...(options.fonts ? { registered: options.fonts } : {}),
+        });
+        this.renderScheduler = new RenderScheduler(this.limits.maxConcurrentRenders);
+    }
+    createViewer(options = {}) {
+        this.#assertAlive();
+        const runtime = {
+            registry: this.registry,
+            fetch: this.fetch,
+            limits: this.limits,
+            fonts: this.fonts,
+            renderScheduler: this.renderScheduler,
+            ...(this.logger ? { logger: this.logger } : {}),
+            ...(this.assetBaseUrl ? { assetBaseUrl: this.assetBaseUrl } : {}),
+            release: (viewer) => this.#viewers.delete(viewer),
+        };
+        const viewer = new DocumentViewer(options, runtime);
+        this.#viewers.add(viewer);
+        return viewer;
+    }
+    registerAdapter(adapter) {
+        this.#assertAlive();
+        return this.registry.register(adapter);
+    }
+    async destroy() {
+        if (this.#destroyed)
+            return;
+        this.#destroyed = true;
+        await Promise.all([...this.#viewers].map(async (viewer) => viewer.destroy()));
+        this.#viewers.clear();
+        await this.registry.destroy();
+        await this.fonts.destroy();
+    }
+    #assertAlive() {
+        if (this.#destroyed)
+            throw new ViewerError("lifecycle-error", "ViewerClient is destroyed");
+    }
+}

package/dist/contracts.d.ts

@@ -0,0 +1,379 @@
+export declare const supportedFormats: readonly ["docx", "docm", "xlsx", "xlsm", "pptx", "pptm", "ppsx", "doc", "xls", "ppt", "pdf", "csv", "tsv", "png", "jpeg", "gif", "webp", "svg", "bmp", "tiff"];
+export type DocumentFormat = (typeof supportedFormats)[number];
+export type ViewerLocale = "en" | "ru";
+export type FitMode = "none" | "page" | "width";
+export type ViewerStatus = "idle" | "loading" | "ready" | "error" | "destroyed";
+export type RenderUnit = "page" | "slide" | "sheet" | "image";
+export type ViewerErrorCode = "unsupported-format" | "fidelity-unsupported" | "invalid-file" | "encrypted-document" | "resource-limit" | "network-error" | "aborted" | "font-unavailable" | "render-failed" | "worker-crashed" | "lifecycle-error" | "internal";
+export type ViewerWarningCode = "format-hint-mismatch" | "unsupported-feature" | "font-substitution" | "font-unavailable" | "external-resource-blocked" | "fidelity-degraded";
+export interface ViewerErrorData {
+    readonly name: "ViewerError";
+    readonly code: ViewerErrorCode;
+    readonly message: string;
+    readonly details?: Readonly<Record<string, unknown>>;
+}
+export interface ViewerWarning {
+    readonly code: ViewerWarningCode;
+    readonly message: string;
+    readonly details?: Readonly<Record<string, unknown>>;
+}
+export interface ViewerProgress {
+    readonly phase: "loading" | "detecting" | "parsing" | "converting" | "rendering";
+    readonly loaded?: number;
+    readonly total?: number;
+    readonly ratio?: number;
+}
+export interface ResourceLimits {
+    readonly maxInputBytes: number;
+    readonly maxExpandedOfficeBytes: number;
+    readonly maxZipEntryBytes: number;
+    readonly maxDecodedPixels: number;
+    readonly maxSvgBytes: number;
+    readonly maxCsvCells: number;
+    readonly maxTextMapBytes: number;
+    readonly maxDocumentUnits: number;
+    readonly maxConcurrentRenders: number;
+    readonly maxOperationMs: number;
+}
+export type BinaryDocumentSource = ArrayBuffer | Uint8Array | Blob;
+export type DocumentSource = BinaryDocumentSource | URL | string;
+export interface OpenDocumentOptions {
+    readonly fileName?: string;
+    readonly contentType?: string;
+    readonly format?: DocumentFormat;
+    readonly signal?: AbortSignal;
+    readonly limits?: Partial<ResourceLimits>;
+}
+export type ViewerFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export type FontPolicyMode = "auto" | "offline" | "custom";
+export type FontStyle = "normal" | "italic" | "oblique";
+export type FontScript = "latin" | "cyrillic" | "cjk" | "japanese" | "korean" | "arabic" | "devanagari" | "bengali" | "gujarati" | "gurmukhi" | "odia" | "tamil" | "telugu" | "kannada" | "malayalam" | "unknown";
+export type FontBinarySource = ArrayBuffer | Uint8Array;
+export type FontSource = FontBinarySource | URL | string;
+export interface FontRequest {
+    readonly family?: string;
+    readonly weight: number;
+    readonly style: FontStyle;
+    readonly script: FontScript;
+    readonly codepoints: readonly number[];
+}
+export interface FontResolution {
+    readonly family?: string;
+    readonly source: FontSource;
+    readonly weight?: number;
+    readonly style?: FontStyle;
+}
+export type FontResolver = (request: FontRequest, signal: AbortSignal) => FontResolution | null | Promise<FontResolution | null>;
+export interface FontPolicy {
+    readonly mode?: FontPolicyMode;
+    readonly resolver?: FontResolver;
+}
+export interface RegisteredFont {
+    readonly family: string;
+    readonly source: FontSource;
+    readonly weight?: number;
+    readonly style?: FontStyle;
+    readonly scripts?: readonly FontScript[];
+}
+export interface ViewerTranslations {
+    readonly previous: string;
+    readonly next: string;
+    readonly page: string;
+    readonly of: string;
+    readonly zoomIn: string;
+    readonly zoomOut: string;
+    readonly fitWidth: string;
+    readonly fitPage: string;
+    readonly search: string;
+    readonly searchPlaceholder: string;
+    readonly matches: string;
+    readonly thumbnails: string;
+    readonly fullscreen: string;
+    readonly exitFullscreen: string;
+    readonly download: string;
+    readonly sheets: string;
+    readonly selectedRange: string;
+    readonly loading: string;
+    readonly close: string;
+    readonly noMatches: string;
+}
+export interface ViewerLogger {
+    debug?(message: string, details?: Readonly<Record<string, unknown>>): void;
+    warn?(message: string, details?: Readonly<Record<string, unknown>>): void;
+    error?(message: string, details?: Readonly<Record<string, unknown>>): void;
+}
+export interface ViewerOptions {
+    readonly container?: HTMLElement;
+    readonly locale?: ViewerLocale;
+    readonly ui?: boolean;
+    readonly initialZoom?: number;
+    readonly fit?: FitMode;
+    readonly useWorker?: boolean;
+    readonly layout?: "continuous" | "single";
+    readonly overscan?: number;
+    readonly translations?: Partial<ViewerTranslations>;
+}
+export interface ViewerClientOptions {
+    readonly fetch?: ViewerFetch;
+    readonly logger?: ViewerLogger;
+    readonly assetBaseUrl?: string | URL;
+    readonly limits?: Partial<ResourceLimits>;
+    readonly adapters?: readonly DocumentAdapter[];
+    readonly fontPolicy?: FontPolicy;
+    readonly fonts?: readonly RegisteredFont[];
+}
+export interface ViewerState {
+    readonly status: ViewerStatus;
+    readonly format?: DocumentFormat;
+    readonly pageIndex: number;
+    readonly pageCount: number;
+    readonly zoom: number;
+    readonly fit: FitMode;
+    readonly panX: number;
+    readonly panY: number;
+}
+export interface TextRun {
+    readonly text: string;
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+    readonly direction?: "ltr" | "rtl";
+    readonly fontFamily?: string;
+    readonly fontWeight?: number;
+    readonly fontStyle?: FontStyle;
+    /** Exact CSS font shorthand used by a canvas renderer. */
+    readonly font?: string;
+    /** Font size in the run coordinate space, in CSS pixels. */
+    readonly fontSize?: number;
+    /** Uniform canvas letter spacing in the run coordinate space. */
+    readonly letterSpacingPx?: number;
+    /** Renderer-provided CSS transform for rotated/vertical glyph runs. */
+    readonly transform?: string;
+    /** True for a horizontal-in-vertical (tate-chu-yoko) run. */
+    readonly eastAsianVert?: boolean;
+    /** Selectable overlay implementation that owns this run's geometry. */
+    readonly textLayer?: "docx" | "pdf" | "pptx" | "generic";
+    /** Unscaled coordinate-space width/height shared by all runs on a unit. */
+    readonly coordinateWidth?: number;
+    readonly coordinateHeight?: number;
+    /** UTF-16 offsets in the page's logical text stream. */
+    readonly logicalStart?: number;
+    readonly logicalEnd?: number;
+    readonly hyperlink?: HyperlinkTarget;
+    readonly row?: number;
+    readonly column?: number;
+}
+export type HyperlinkTarget = {
+    readonly kind: "external";
+    readonly url: string;
+} | {
+    readonly kind: "internal";
+    readonly ref: string;
+    readonly pageIndex?: number;
+};
+export interface TextSelection {
+    readonly pageIndex: number;
+    readonly endPageIndex?: number;
+    readonly startOffset?: number;
+    readonly endOffset?: number;
+    readonly text: string;
+    readonly runs: readonly TextRun[];
+}
+export interface TextSelectionRange {
+    readonly startPageIndex: number;
+    readonly startOffset: number;
+    readonly endPageIndex: number;
+    readonly endOffset: number;
+}
+export interface CellRange {
+    readonly sheetIndex: number;
+    readonly startRow: number;
+    readonly startColumn: number;
+    readonly endRow: number;
+    readonly endColumn: number;
+}
+/** A non-contiguous spreadsheet selection, ordered by interaction order. */
+export interface CellSelection {
+    readonly sheetIndex: number;
+    readonly ranges: readonly CellRange[];
+}
+export interface ViewerEventMap {
+    readonly statechange: ViewerState;
+    readonly ready: ViewerState;
+    readonly error: ViewerErrorData;
+    readonly warning: ViewerWarning;
+    readonly progress: ViewerProgress;
+    readonly selectionchange: TextSelection | CellRange | CellSelection | null;
+    readonly pagechange: {
+        readonly pageIndex: number;
+        readonly pageCount: number;
+    };
+    readonly zoomchange: {
+        readonly zoom: number;
+        readonly fit: FitMode;
+    };
+    readonly viewchange: ViewerState;
+    readonly searchchange: SearchResult | null;
+}
+export interface SearchOptions {
+    readonly caseSensitive?: boolean;
+    /**
+     * Inclusive 0-based page range to scan, as `[first, last]`. Restricts both
+     * the pages whose text is read and the returned matches; omit to search the
+     * whole document. A reversed range is normalized; an out-of-range endpoint
+     * is rejected.
+     */
+    readonly pageRange?: readonly [number, number];
+}
+export interface SearchMatch {
+    readonly pageIndex: number;
+    readonly start: number;
+    readonly end: number;
+    readonly text: string;
+}
+export interface SearchResult {
+    readonly query: string;
+    readonly matches: readonly SearchMatch[];
+    readonly activeIndex: number;
+}
+export interface HeadlessRenderOptions {
+    readonly zoom?: number;
+    readonly devicePixelRatio?: number;
+    readonly width?: number;
+    readonly height?: number;
+    /** Unscaled pixels hidden before the first rendered spreadsheet column. */
+    readonly scrollOffsetX?: number;
+    /** Unscaled pixels hidden before the first rendered spreadsheet row. */
+    readonly scrollOffsetY?: number;
+    /** View-only spreadsheet column widths in unscaled CSS pixels, keyed from 1. */
+    readonly columnWidths?: Readonly<Record<number, number>>;
+    readonly signal?: AbortSignal;
+    readonly priority?: "visible" | "adjacent" | "background";
+}
+export interface ThumbnailRenderOptions {
+    readonly maxWidth?: number;
+    readonly maxHeight?: number;
+    readonly devicePixelRatio?: number;
+    readonly signal?: AbortSignal;
+}
+export interface RenderViewport {
+    readonly pageIndex: number;
+    readonly zoom: number;
+    readonly devicePixelRatio: number;
+    readonly width?: number;
+    readonly height?: number;
+    readonly scrollOffsetX?: number;
+    readonly scrollOffsetY?: number;
+    readonly columnWidths?: Readonly<Record<number, number>>;
+    readonly sheetRange?: SpreadsheetViewportRange;
+}
+export interface SpreadsheetViewportRange {
+    readonly row: number;
+    readonly column: number;
+    readonly rowCount: number;
+    readonly columnCount: number;
+}
+export interface SpreadsheetMergedRange {
+    readonly startRow: number;
+    readonly startColumn: number;
+    readonly endRow: number;
+    readonly endColumn: number;
+}
+export interface SpreadsheetSheetInfo {
+    readonly name: string;
+    readonly frozenRows: number;
+    readonly frozenColumns: number;
+    readonly mergedRanges: readonly SpreadsheetMergedRange[];
+    readonly maxRow: number;
+    readonly maxColumn: number;
+    /** Geometry is expressed in unscaled CSS pixels and uses 1-based indexes. */
+    readonly defaultColumnWidth?: number;
+    readonly defaultRowHeight?: number;
+    readonly columnWidths?: Readonly<Record<number, number>>;
+    readonly rowHeights?: Readonly<Record<number, number>>;
+    readonly rowHeaderWidth?: number;
+    readonly columnHeaderHeight?: number;
+    readonly rightToLeft?: boolean;
+}
+export interface PageSize {
+    /** Natural page width in CSS pixels at zoom 1. */
+    readonly width: number;
+    /** Natural page height in CSS pixels at zoom 1. */
+    readonly height: number;
+}
+export interface DocumentInfo {
+    readonly format: DocumentFormat;
+    readonly unit: RenderUnit;
+    readonly pageCount: number;
+    readonly sheetNames?: readonly string[];
+    readonly sheets?: readonly SpreadsheetSheetInfo[];
+    /** Natural page geometry, in document order, when exposed by the backend. */
+    readonly pageSizes?: readonly PageSize[];
+    readonly warnings?: readonly ViewerWarning[];
+    readonly capabilities?: DocumentCapabilities;
+}
+export interface DocumentCapabilities {
+    readonly textSelection: boolean;
+    readonly cellSelection: boolean;
+    readonly search: boolean;
+    readonly thumbnails: boolean;
+}
+export type DocumentMetadata = DocumentInfo;
+export interface AdapterOpenContext {
+    readonly format: DocumentFormat;
+    readonly fileName?: string;
+    readonly contentType?: string;
+    readonly signal: AbortSignal;
+    readonly limits: ResourceLimits;
+    readonly assetBaseUrl?: URL;
+    readonly reportProgress: (progress: ViewerProgress) => void;
+    readonly reportWarning: (warning: ViewerWarning) => void;
+}
+export interface DocumentAdapter<THandle = unknown> {
+    readonly id: string;
+    readonly formats: readonly DocumentFormat[];
+    open(data: Uint8Array, context: AdapterOpenContext): Promise<THandle>;
+    getInfo(handle: THandle): Promise<DocumentInfo>;
+    render(handle: THandle, target: HTMLCanvasElement | OffscreenCanvas, viewport: RenderViewport, signal?: AbortSignal): Promise<void>;
+    getTextMap?(handle: THandle, pageIndex: number, signal?: AbortSignal): Promise<readonly TextRun[]>;
+    close(handle: THandle): void | Promise<void>;
+    destroy?(): void | Promise<void>;
+}
+export type ViewerEventListener<K extends keyof ViewerEventMap> = (event: ViewerEventMap[K]) => void;
+export interface ViewerApi {
+    readonly state: ViewerState;
+    load(source: DocumentSource, options?: OpenDocumentOptions): Promise<void>;
+    open(source: DocumentSource, options?: OpenDocumentOptions): Promise<void>;
+    close(): Promise<void>;
+    setZoom(zoom: number): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    setFit(mode: FitMode): void;
+    fitWidth(): void;
+    fitPage(): void;
+    panBy(deltaX: number, deltaY: number): void;
+    goToPage(pageIndex: number): void;
+    next(): void;
+    previous(): void;
+    setSheet(sheetIndex: number): void;
+    renderPage(pageIndex: number, target: HTMLCanvasElement | OffscreenCanvas, options?: HeadlessRenderOptions): Promise<void>;
+    renderThumbnail(pageIndex: number, target: HTMLCanvasElement | OffscreenCanvas, options?: ThumbnailRenderOptions): Promise<void>;
+    renderSheetViewport(sheetIndex: number, target: HTMLCanvasElement | OffscreenCanvas, range: SpreadsheetViewportRange, options?: HeadlessRenderOptions): Promise<void>;
+    getPageText(pageIndex: number, signal?: AbortSignal): Promise<string>;
+    getDocumentInfo(): DocumentInfo;
+    search(query: string, options?: SearchOptions): Promise<SearchResult>;
+    searchNext(): SearchResult | null;
+    searchPrevious(): SearchResult | null;
+    clearSearch(): void;
+    getSelection(): TextSelection | CellRange | CellSelection | null;
+    selectText(range: TextSelectionRange): Promise<TextSelection>;
+    selectCells(range: CellRange): CellRange;
+    selectCellRanges(ranges: readonly CellRange[]): CellSelection;
+    clearSelection(): void;
+    copySelection(): Promise<string>;
+    getOriginalBytes(): Uint8Array | undefined;
+    downloadOriginal(fileName?: string): Blob;
+    on<K extends keyof ViewerEventMap>(type: K, listener: ViewerEventListener<K>): () => void;
+    destroy(): Promise<void>;
+}

package/dist/contracts.js

@@ -0,0 +1,22 @@
+export const supportedFormats = [
+    "docx",
+    "docm",
+    "xlsx",
+    "xlsm",
+    "pptx",
+    "pptm",
+    "ppsx",
+    "doc",
+    "xls",
+    "ppt",
+    "pdf",
+    "csv",
+    "tsv",
+    "png",
+    "jpeg",
+    "gif",
+    "webp",
+    "svg",
+    "bmp",
+    "tiff",
+];

package/dist/csv-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/csv-worker.js

@@ -0,0 +1,17 @@
+import { parseDelimitedBytes } from "./adapters/csv-parser.js";
+const workerScope = self;
+workerScope.onmessage = (event) => {
+    try {
+        const result = parseDelimitedBytes(new Uint8Array(event.data.data), event.data.format, event.data.maxCells);
+        workerScope.postMessage({ ok: true, result });
+    }
+    catch (error) {
+        workerScope.postMessage({
+            ok: false,
+            message: error instanceof Error ? error.message : String(error),
+            code: typeof error === "object" && error !== null && "code" in error
+                ? String(error.code)
+                : "invalid-file",
+        });
+    }
+};

package/dist/detect.d.ts

@@ -0,0 +1,15 @@
+import type { DocumentFormat, ViewerWarning } from "./contracts.js";
+export interface FormatHints {
+    readonly fileName?: string;
+    readonly contentType?: string;
+    readonly format?: DocumentFormat;
+}
+export interface FormatDetection {
+    readonly format: DocumentFormat;
+    readonly confidence: "magic" | "container" | "hint";
+    readonly warnings: readonly ViewerWarning[];
+}
+export declare function detectFormat(data: Uint8Array, hints?: FormatHints): FormatDetection;
+export declare function formatFromFileName(fileName: string): DocumentFormat | undefined;
+export declare function formatFromMime(contentType?: string): DocumentFormat | undefined;
+export declare function sniffFormat(data: Uint8Array): DocumentFormat | undefined;