4f:I[707087,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/3j06ow7w40nxu.js","/_next/static/immutable/chunks/31nn7jwsjvqii.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"RegistryDependencies"] 50:I[314491,["/_next/static/immutable/chunks/3arlv5bvukoo2.js","/_next/static/immutable/chunks/39v64hmfyo-sr.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/04j_o97cgxn2x.js","/_next/static/immutable/chunks/3upr08c9vtj8w.js","/_next/static/immutable/chunks/1ww0328si-u8x.js","/_next/static/immutable/chunks/11mfl5ymqld9-.js","/_next/static/immutable/chunks/2xxcqy6ppds3l.js","/_next/static/immutable/chunks/3j06ow7w40nxu.js","/_next/static/immutable/chunks/31nn7jwsjvqii.js","/_next/static/immutable/chunks/43_s7jweyypoh.js","/_next/static/immutable/chunks/0p6vao205o1jc.js","/_next/static/immutable/chunks/1_kyvgkyokw92.js","/_next/static/immutable/chunks/1lo-zn37dolb5.js","/_next/static/immutable/chunks/1v8k6yxw1rg0u.js"],"FilesView"] 51:T2b65,import { isResourceError, isViewerFormatError, ViewerFormatError, type ViewerFormatErrorMapperOptions, } from "@/lib/viewer-errors"; import type { PdfDocumentProxy, PdfjsModule, PdfPageProxy, } from "@/lib/pdf-document-types"; import type { ViewerContentBytes, ViewerContentDirectUrl, ViewerContentIdentity, } from "@/lib/viewer-resource"; const PDF_CACHE_MAX = 6; type PdfDocumentContent = ViewerContentIdentity & ViewerContentDirectUrl & ViewerContentBytes; type DocumentCacheEntry = { loadKey: string; promise: Promise; consumers: number; lastUsedAt: number; retainRejected: boolean; status: "pending" | "resolved" | "rejected"; document?: PdfDocumentProxy; error?: unknown; }; type PageCacheEntry = { promise: Promise; retainRejected: boolean; status: "pending" | "resolved" | "rejected"; page?: PdfPageProxy; error?: unknown; }; type PdfResourceOptions = { retainRejected?: boolean; }; let pdfjsPromise: Promise | null = null; const documentCache = new Map(); const pageCache = new WeakMap>(); const detachedDocumentEntries = new Set(); let pruneTimer = 0; function loadPdfjs(): Promise { if (!pdfjsPromise) { pdfjsPromise = import("pdfjs-dist/legacy/build/pdf.mjs").then((pdfjs) => { const pdfjsModule = pdfjs as unknown as PdfjsModule; if (!pdfjsModule.GlobalWorkerOptions.workerSrc) { pdfjsModule.GlobalWorkerOptions.workerSrc = new URL( "pdfjs-dist/legacy/build/pdf.worker.min.mjs", import.meta.url, ).toString(); } return pdfjsModule; }); } return pdfjsPromise; } function scheduleDocumentPrune() { if (typeof window === "undefined" || pruneTimer) return; pruneTimer = window.setTimeout(() => { pruneTimer = 0; pruneDocumentCache(); }, 0); } function pruneDocumentCache() { while (documentCache.size > PDF_CACHE_MAX) { let evictKey: string | null = null; let evictEntry: DocumentCacheEntry | null = null; for (const [key, documentEntry] of documentCache) { if (documentEntry.consumers > 0 || documentEntry.status === "pending") { continue; } if (!evictEntry || documentEntry.lastUsedAt < evictEntry.lastUsedAt) { evictKey = key; evictEntry = documentEntry; } } if (!evictKey || !evictEntry) return; documentCache.delete(evictKey); if (evictEntry.status === "resolved") { if (!hasDetachedDocument(evictEntry.document)) { destroyPdfDocument(evictEntry.document); } } } } export function getPdfDocumentResource( content: PdfDocumentContent, options: PdfResourceOptions = {}, ): Promise { return getDocumentCacheEntry(content, options).promise; } export function readPdfDocumentResource( content: PdfDocumentContent, ): PdfDocumentProxy { const documentEntry = getDocumentCacheEntry(content, { retainRejected: true, }); documentEntry.lastUsedAt = Date.now(); if (documentEntry.status === "pending") throw documentEntry.promise; if (documentEntry.status === "rejected") throw documentEntry.error; return documentEntry.document!; } function getDocumentCacheEntry( content: PdfDocumentContent, options: PdfResourceOptions, ) { const loadKey = content.key; const cachedDocumentEntry = documentCache.get(loadKey); if (cachedDocumentEntry) { if (options.retainRejected) { cachedDocumentEntry.retainRejected = true; } if (cachedDocumentEntry.status === "rejected" && !options.retainRejected) { documentCache.delete(loadKey); } else { cachedDocumentEntry.lastUsedAt = Date.now(); return cachedDocumentEntry; } } const documentEntry: DocumentCacheEntry = { loadKey, promise: Promise.resolve(null as never), consumers: 0, lastUsedAt: Date.now(), retainRejected: Boolean(options.retainRejected), status: "pending", }; documentEntry.promise = loadPdfjs() .then((pdfjs) => getPdfDocument(content, pdfjs)) .then( (document) => { documentEntry.status = "resolved"; documentEntry.document = document; if (documentCache.get(loadKey) !== documentEntry) { destroyPdfDocument(document); } else { scheduleDocumentPrune(); } return document; }, (error) => { documentEntry.status = "rejected"; documentEntry.error = error; if ( !documentEntry.retainRejected && documentCache.get(loadKey) === documentEntry ) { documentCache.delete(loadKey); } throw error; }, ); documentCache.set(loadKey, documentEntry); scheduleDocumentPrune(); return documentEntry; } export function clearPdfDocumentResource(content: ViewerContentIdentity) { const documentEntry = documentCache.get(content.key); if (!documentEntry) return; documentCache.delete(content.key); if (documentEntry.status === "resolved") { clearPageCache(documentEntry.document); if (documentEntry.consumers > 0) { detachedDocumentEntries.add(documentEntry); } else if (hasDetachedDocument(documentEntry.document)) { return; } else { destroyPdfDocument(documentEntry.document); } } } export function retainPdfDocumentResource( content: ViewerContentIdentity, document: PdfDocumentProxy, ) { const documentEntry = documentCache.get(content.key); if (!documentEntry || documentEntry.document !== document) return; documentEntry.consumers += 1; documentEntry.lastUsedAt = Date.now(); } export function releasePdfDocumentResource( content: ViewerContentIdentity, document: PdfDocumentProxy, ) { const documentEntry = findDetachedDocumentEntry(content, document) ?? findAttachedDocumentEntry(content, document); if (!documentEntry || documentEntry.document !== document) return; documentEntry.consumers = Math.max(0, documentEntry.consumers - 1); documentEntry.lastUsedAt = Date.now(); if (detachedDocumentEntries.has(documentEntry)) { if (documentEntry.consumers === 0) { detachedDocumentEntries.delete(documentEntry); if (!hasAttachedDocument(documentEntry.document)) { destroyPdfDocument(documentEntry.document); } } return; } scheduleDocumentPrune(); } export function resetPdfDocumentResourceCacheForTests() { pdfjsPromise = null; if (pruneTimer && typeof window !== "undefined") { window.clearTimeout(pruneTimer); pruneTimer = 0; } const destroyedDocuments = new Set(); for (const documentEntry of documentCache.values()) { if (documentEntry.status === "resolved") { destroyPdfDocumentOnce(documentEntry.document, destroyedDocuments); } } for (const documentEntry of detachedDocumentEntries) { if (documentEntry.status === "resolved") { destroyPdfDocumentOnce(documentEntry.document, destroyedDocuments); } } documentCache.clear(); detachedDocumentEntries.clear(); } function findAttachedDocumentEntry( content: ViewerContentIdentity, document: PdfDocumentProxy, ) { const documentEntry = documentCache.get(content.key); return documentEntry?.document === document ? documentEntry : undefined; } function findDetachedDocumentEntry( content: ViewerContentIdentity, document: PdfDocumentProxy, ) { for (const documentEntry of detachedDocumentEntries) { if ( documentEntry.loadKey === content.key && documentEntry.document === document ) { return documentEntry; } } return undefined; } function hasAttachedDocument(document: PdfDocumentProxy | undefined) { for (const documentEntry of documentCache.values()) { if (documentEntry.document === document) return true; } return false; } function hasDetachedDocument(document: PdfDocumentProxy | undefined) { for (const documentEntry of detachedDocumentEntries) { if (documentEntry.document === document) return true; } return false; } export function getPdfPageResource( document: PdfDocumentProxy, pageNumber: number, options: PdfResourceOptions = {}, ) { return getPageCacheEntry(document, pageNumber, options).promise; } export function readPdfPageResource( document: PdfDocumentProxy, pageNumber: number, ): PdfPageProxy { const pageEntry = getPageCacheEntry(document, pageNumber, { retainRejected: true, }); if (pageEntry.status === "pending") throw pageEntry.promise; if (pageEntry.status === "rejected") throw pageEntry.error; return pageEntry.page!; } function getPageCacheEntry( document: PdfDocumentProxy, pageNumber: number, options: PdfResourceOptions, ) { let pages = pageCache.get(document); if (!pages) { pages = new Map(); pageCache.set(document, pages); } const cachedPageEntry = pages.get(pageNumber); if (cachedPageEntry) { if (options.retainRejected) { cachedPageEntry.retainRejected = true; } if (cachedPageEntry.status === "rejected" && !options.retainRejected) { pages.delete(pageNumber); } else { return cachedPageEntry; } } const pageEntry: PageCacheEntry = { promise: document.getPage(pageNumber), retainRejected: Boolean(options.retainRejected), status: "pending", }; pages.set(pageNumber, pageEntry); pageEntry.promise.then( (page) => { pageEntry.status = "resolved"; pageEntry.page = page; }, (error) => { pageEntry.status = "rejected"; pageEntry.error = error; if (!pageEntry.retainRejected && pages?.get(pageNumber) === pageEntry) { pages.delete(pageNumber); } }, ); return pageEntry; } async function getPdfDocument( content: PdfDocumentContent, pdfjs: PdfjsModule, ): Promise { try { if (content.directUrl) { return await pdfjs.getDocument(content.directUrl).promise; } const buffer = await content.readBytes(); return await pdfjs.getDocument({ data: new Uint8Array(buffer) }).promise; } catch (error) { if (isResourceError(error)) throw error; throw toPdfFormatError(error, { kind: "parse_failed", message: "Failed to parse PDF.", }); } } function toPdfFormatError( error: unknown, options: ViewerFormatErrorMapperOptions, ): ViewerFormatError { if (isViewerFormatError(error)) return error; return new ViewerFormatError({ format: "pdf", kind: options.kind, message: options.message, cause: error, }); } function destroyPdfDocument(document: PdfDocumentProxy | undefined) { clearPageCache(document); void document?.destroy().catch(() => {}); } function destroyPdfDocumentOnce( document: PdfDocumentProxy | undefined, destroyedDocuments: Set, ) { if (!document || destroyedDocuments.has(document)) return; destroyedDocuments.add(document); destroyPdfDocument(document); } function clearPageCache(document: PdfDocumentProxy | undefined) { if (document) pageCache.delete(document); } 52:T2d3a,export type ViewerFormat = | "pdf" | "image" | "text" | "csv" | "docx" | "xlsx" | "pptx" | "file"; export type ViewerErrorDomain = | "resource" | "format" | "state" | "unsupported" | "unknown"; export type ResourceErrorKind = | "fetch_failed" | "http_error" | "aborted" | "invalid_range" | "partial_content" | "too_large" | "unsupported_capability" | "unknown"; export type ResourceTooLargeReason = "bytes" | "lines"; export class ResourceError extends Error { readonly domain = "resource"; readonly kind: ResourceErrorKind; readonly status?: number; readonly tooLargeReason?: ResourceTooLargeReason; override readonly cause?: unknown; constructor({ kind, message, status, tooLargeReason, cause, }: { kind: ResourceErrorKind; message: string; status?: number; tooLargeReason?: ResourceTooLargeReason; cause?: unknown; }) { super(message); this.name = "ResourceError"; this.kind = kind; this.status = status; this.tooLargeReason = tooLargeReason; this.cause = cause; } } export type ViewerFormatErrorKind = | "bounds" | "decode_failed" | "disposed" | "index_out_of_range" | "load_failed" | "parse_failed" | "render_failed" | "worker_failed" | "unknown"; export interface ViewerFormatErrorMapperOptions { kind: ViewerFormatErrorKind; message: string; } export class ViewerFormatError extends Error { readonly domain = "format"; readonly format: ViewerFormat; readonly kind: ViewerFormatErrorKind; override readonly cause?: unknown; constructor({ format, kind, message, cause, }: { format: ViewerFormat; kind: ViewerFormatErrorKind; message: string; cause?: unknown; }) { super(message); this.name = "ViewerFormatError"; this.format = format; this.kind = kind; this.cause = cause; } } export type ViewerStateErrorKind = | "invalid_bounds" | "invalid_target" | "out_of_range" | "stale_resource" | "unknown"; export class ViewerStateError extends Error { readonly domain = "state"; readonly format?: ViewerFormat; readonly kind: ViewerStateErrorKind; override readonly cause?: unknown; constructor({ format, kind, message, cause, }: { format?: ViewerFormat; kind: ViewerStateErrorKind; message: string; cause?: unknown; }) { super(message); this.name = "ViewerStateError"; this.format = format; this.kind = kind; this.cause = cause; } } export class ViewerUnsupportedError extends Error { readonly domain = "unsupported"; readonly format?: ViewerFormat; readonly sourceKind?: string; override readonly cause?: unknown; constructor({ format, sourceKind, message, cause, }: { format?: ViewerFormat; sourceKind?: string; message: string; cause?: unknown; }) { super(message); this.name = "ViewerUnsupportedError"; this.format = format; this.sourceKind = sourceKind; this.cause = cause; } } export interface ViewerErrorInfo { domain: ViewerErrorDomain; format?: ViewerFormat; kind: string; message: string; status?: number; isRetryable: boolean; isDownloadUseful: boolean; userMessage: string; cause?: unknown; } export interface ViewerErrorContext { format?: ViewerFormat; sourceKind?: "url" | "blob" | "text"; canDownload?: boolean; retry?: "auto" | "always" | "never"; } export function isAbortError(error: unknown): boolean { return ( (error instanceof DOMException && error.name === "AbortError") || (error instanceof Error && error.name === "AbortError") ); } export function isResourceError(error: unknown): error is ResourceError { return ( error instanceof ResourceError || isErrorLike(error, "ResourceError", "resource") ); } export function isViewerFormatError( error: unknown, ): error is ViewerFormatError { return ( error instanceof ViewerFormatError || isErrorLike(error, "ViewerFormatError", "format") ); } export function isViewerStateError(error: unknown): error is ViewerStateError { return ( error instanceof ViewerStateError || isErrorLike(error, "ViewerStateError", "state") ); } export function isViewerUnsupportedError( error: unknown, ): error is ViewerUnsupportedError { return ( error instanceof ViewerUnsupportedError || isErrorLike(error, "ViewerUnsupportedError", "unsupported") ); } export function toViewerErrorInfo( error: unknown, context: ViewerErrorContext = {}, ): ViewerErrorInfo { const canDownload = context.canDownload ?? true; if (isResourceError(error)) { return { domain: "resource", format: context.format, kind: error.kind, message: error.message, status: error.status, isRetryable: retryable( context, resourceErrorDefaultRetry(error, context), ), isDownloadUseful: canDownload && error.kind !== "aborted", userMessage: resourceErrorUserMessage(error), cause: error.cause, }; } if (isViewerFormatError(error)) { const format = error.format ?? context.format; return { domain: "format", format, kind: error.kind, message: error.message, isRetryable: retryable( context, formatErrorDefaultRetry(error, context, format), ), isDownloadUseful: canDownload, userMessage: formatErrorUserMessage(format, error.kind, error), cause: error.cause, }; } if (isViewerStateError(error)) { return { domain: "state", format: error.format ?? context.format, kind: error.kind, message: error.message, isRetryable: retryable(context, false), isDownloadUseful: canDownload, userMessage: stateErrorUserMessage(error.kind), cause: error.cause, }; } if (isViewerUnsupportedError(error)) { return { domain: "unsupported", format: error.format ?? context.format, kind: "unsupported", message: error.message, isRetryable: retryable(context, false), isDownloadUseful: canDownload, userMessage: "This file cannot be previewed here.", cause: error.cause, }; } if (isAbortError(error)) { return { domain: "resource", format: context.format, kind: "aborted", message: "Loading was cancelled.", isRetryable: retryable(context, false), isDownloadUseful: false, userMessage: "Loading was cancelled.", cause: error, }; } const message = error instanceof Error ? error.message : String(error); return { domain: "unknown", format: context.format, kind: "unknown", message, isRetryable: retryable(context, unknownErrorDefaultRetry(context)), isDownloadUseful: canDownload, userMessage: fallbackUserMessage(context.format), cause: error, }; } function isErrorLike(error: unknown, name: string, domain: ViewerErrorDomain) { if (!error || typeof error !== "object") return false; const candidate = error as { name?: unknown; domain?: unknown; kind?: unknown; }; return ( (candidate.name === name || candidate.domain === domain) && typeof candidate.kind === "string" ); } function retryable(context: ViewerErrorContext, fallback: boolean) { if (context.retry === "always") return true; if (context.retry === "never") return false; return fallback; } function resourceErrorDefaultRetry( error: ResourceError, context: ViewerErrorContext, ) { if (error.kind === "aborted") return false; if (error.kind === "invalid_range") return false; if (error.kind === "too_large") return false; if (error.kind === "unsupported_capability") return false; return context.sourceKind === "url"; } function formatErrorDefaultRetry( error: ViewerFormatError, context: ViewerErrorContext, format: ViewerFormat | undefined, ) { if (format === "text" && error.kind === "bounds") return false; if (error.kind === "disposed") return false; if (error.kind === "index_out_of_range") return false; if (format === "docx") return true; return context.sourceKind === "url"; } function unknownErrorDefaultRetry(context: ViewerErrorContext) { if (context.format === "docx") return true; return context.sourceKind === "url"; } function resourceErrorUserMessage(error: ResourceError) { if (error.kind === "http_error") { return error.status ? `Failed to load file: ${error.status}.` : "Couldn't load this file."; } if (error.kind === "fetch_failed") return "Couldn't load this file."; if (error.kind === "aborted") return "Loading was cancelled."; if (error.kind === "invalid_range") return "This source range is invalid."; if (error.kind === "too_large") { return error.tooLargeReason === "lines" ? "This file has too many lines to preview." : "This file is too large to preview."; } if (error.kind === "partial_content") { return "This source returned partial content and cannot be previewed here."; } if (error.kind === "unsupported_capability") { return "This source cannot be previewed here."; } return "Couldn't load this file."; } function formatErrorUserMessage( format: ViewerFormat | undefined, kind: string, error?: unknown, ) { if (format === "pdf") return "Couldn't load this PDF."; if (format === "image") { if (kind === "index_out_of_range") return "This image page is out of range."; if (kind === "decode_failed") return "Couldn't decode this image."; return "Couldn't load this image."; } if (format === "text") { if (kind === "render_failed") return "Couldn't render this text file."; if (kind === "bounds") { const boundsError = error as { reason?: unknown; boundName?: unknown; }; if (boundsError.reason === "lines") { return "This text file has too many lines to preview."; } if (boundsError.reason === "bytes") { return "This text file is too large to preview."; } if (typeof boundsError.boundName === "string") { return "Text viewer bounds are invalid."; } } return "Couldn't load this text file."; } if (format === "csv") return "Couldn't parse this table."; if (format === "docx") return "Couldn't render this document."; if (format === "xlsx") return "Couldn't parse this spreadsheet."; if (format === "pptx") { if (kind === "render_failed") return "Couldn't render this slide."; return "Couldn't load this presentation."; } return "Couldn't load this file."; } function stateErrorUserMessage(kind: ViewerStateErrorKind) { if (kind === "invalid_bounds") return "Viewer bounds are invalid."; if (kind === "invalid_target") return "The requested target is invalid."; if (kind === "out_of_range") return "The requested item is out of range."; if (kind === "stale_resource") return "This viewer state is no longer valid."; return "Couldn't load this file."; } function fallbackUserMessage(format: ViewerFormat | undefined) { if (format === "pdf") return "Couldn't load this PDF."; if (format === "image") return "Couldn't load this image."; if (format === "text") return "Couldn't load this text file."; if (format === "csv") return "Couldn't parse this table."; if (format === "docx") return "Couldn't load this document."; if (format === "xlsx") return "Couldn't load this spreadsheet."; if (format === "pptx") return "Couldn't load this presentation."; return "Couldn't load this file."; } 53:T6cac,import { createBlobDownloadAction, createHrefDownloadAction, createTextDownloadAction, type ViewerDownloadAction, } from "@/lib/viewer-download-actions"; import { isAbortError, ResourceError, type ResourceTooLargeReason, } from "@/lib/viewer-errors"; import { resolveViewerDescriptor, textPayloadKey, type BlobViewerSource, type FileCategory, type TextSource, type UrlViewerSource, type ViewerDescriptor, type ViewerSource, } from "@/lib/viewer-source"; export interface ResourceReadOptions { cache?: RequestCache; signal?: AbortSignal; } export interface TextReadOptions extends ResourceReadOptions { maxBytes?: number; maxLines?: number; } export interface ByteRange { start: number; end: number; } export interface ByteRangeResult { buffer: ArrayBuffer; contentRange?: { start: number; end: number; total: number | null; }; isComplete: boolean; } export interface ViewerResourceKeys { readonly load: string; readonly presentation: string; readonly resource: string; } export type ViewerResourcePayload = | { kind: "url"; url: string } | { kind: "blob"; blob: Blob } | { kind: "text"; text: string }; export interface ViewerResourceContent { readonly key: string; readonly sourceKind: ViewerSource["kind"]; readonly directUrl: string | null; readonly mimeType?: string; readonly payload: ViewerResourcePayload; readBlob(options?: ResourceReadOptions): Promise; readBytes(options?: ResourceReadOptions): Promise; readText(options?: TextReadOptions): Promise; readStream( options?: ResourceReadOptions, ): Promise>; readRange( range: ByteRange, options?: ResourceReadOptions, ): Promise; } export type ViewerContentIdentity = Pick< ViewerResourceContent, "key" | "sourceKind" >; export type ViewerContentDirectUrl = ViewerContentIdentity & Pick; export type ViewerContentPayload = ViewerContentIdentity & Pick; export type ViewerContentMime = ViewerContentIdentity & Pick; export type ViewerContentBlob = ViewerContentIdentity & Pick; export type ViewerContentBytes = ViewerContentIdentity & Pick; export type ViewerContentText = ViewerContentIdentity & Pick; export type ViewerContentStream = ViewerContentIdentity & Pick; export type ViewerContentRange = ViewerContentIdentity & Pick; export interface ViewerResource { readonly descriptor: ViewerDescriptor; readonly sourceKind: ViewerSource["kind"]; readonly keys: ViewerResourceKeys; readonly identityKey: string; readonly fileName: string; readonly mimeType?: string; readonly content: ViewerResourceContent; readonly originalDownload: ViewerDownloadAction; } const URL_RESOURCE_REGISTRY_MAX = 128; const TEXT_RESOURCE_REGISTRY_MAX = 64; // LF, CR, CRLF, LINE SEPARATOR (U+2028), and PARAGRAPH SEPARATOR (U+2029) — the // ECMAScript LineTerminator set, matching what a browser breaks on in a // `white-space: pre` block. Kept in sync with text-viewer-resource's splitter. const TEXT_LINE_BREAK_PATTERN = /\r\n|[\n\r\u2028\u2029]/g; const urlViewerResourceRegistry = new Map(); const urlViewerResourceContentRegistry = new Map< string, ViewerResourceContent >(); const textViewerResourceRegistry = new Map(); const textViewerResourceContentRegistry = new Map< string, ViewerResourceContent >(); let blobViewerResourceRegistry = new WeakMap< Blob, Map >(); let blobViewerResourceContentRegistry = new WeakMap< Blob, Map >(); const blobObjectKeys = new WeakMap(); let nextBlobObjectKey = 0; export function createViewerResource( source: ViewerSource, category?: FileCategory, ): ViewerResource { const descriptor = resolveViewerDescriptor({ source, category }); const keys = viewerResourceKeys(source, descriptor); if (source.kind === "url") { return internUrlResource(source, descriptor, keys); } if (source.kind === "blob") { return internBlobResource(source, descriptor, keys); } return internTextResource(source, descriptor, keys); } export function clearViewerResourceRegistryForTests() { urlViewerResourceRegistry.clear(); urlViewerResourceContentRegistry.clear(); textViewerResourceRegistry.clear(); textViewerResourceContentRegistry.clear(); blobViewerResourceRegistry = new WeakMap(); blobViewerResourceContentRegistry = new WeakMap(); } function internUrlResource( source: UrlViewerSource, descriptor: ViewerDescriptor, keys: ViewerResourceKeys, ): ViewerResource { const cached = urlViewerResourceRegistry.get(keys.resource); if (cached) return cached; const resource = createUrlResource(source, descriptor, keys); urlViewerResourceRegistry.set(keys.resource, resource); pruneUrlResourceRegistry(); return resource; } function internBlobResource( source: BlobViewerSource, descriptor: ViewerDescriptor, keys: ViewerResourceKeys, ): ViewerResource { let resources = blobViewerResourceRegistry.get(source.blob); if (!resources) { resources = new Map(); blobViewerResourceRegistry.set(source.blob, resources); } const cached = resources.get(keys.resource); if (cached) return cached; const resource = createBlobResource(source, descriptor, keys); resources.set(keys.resource, resource); return resource; } function internTextResource( source: TextSource, descriptor: ViewerDescriptor, keys: ViewerResourceKeys, ): ViewerResource { const cached = textViewerResourceRegistry.get(keys.resource); if (cached) return cached; const resource = createTextResource(source, descriptor, keys); textViewerResourceRegistry.set(keys.resource, resource); pruneTextResourceRegistry(); return resource; } function pruneUrlResourceRegistry() { while (urlViewerResourceRegistry.size > URL_RESOURCE_REGISTRY_MAX) { const firstKey = urlViewerResourceRegistry.keys().next().value; if (!firstKey) return; urlViewerResourceRegistry.delete(firstKey); } } function pruneUrlResourceContentRegistry() { while (urlViewerResourceContentRegistry.size > URL_RESOURCE_REGISTRY_MAX) { const firstKey = urlViewerResourceContentRegistry.keys().next().value; if (!firstKey) return; urlViewerResourceContentRegistry.delete(firstKey); } } function pruneTextResourceRegistry() { while (textViewerResourceRegistry.size > TEXT_RESOURCE_REGISTRY_MAX) { const firstKey = textViewerResourceRegistry.keys().next().value; if (!firstKey) return; textViewerResourceRegistry.delete(firstKey); } } function pruneTextResourceContentRegistry() { while (textViewerResourceContentRegistry.size > TEXT_RESOURCE_REGISTRY_MAX) { const firstKey = textViewerResourceContentRegistry.keys().next().value; if (!firstKey) return; textViewerResourceContentRegistry.delete(firstKey); } } function viewerResourceKeys( source: ViewerSource, descriptor: ViewerDescriptor, ): ViewerResourceKeys { const load = viewerResourceLoadKey(source, descriptor); const presentation = viewerResourcePresentationKey(source, descriptor); return { load, presentation, resource: [load, presentation].join("\u0000"), }; } function viewerResourceLoadKey( source: ViewerSource, descriptor: ViewerDescriptor, ) { return [ source.kind, source.identityKey ?? "", sourceMimeType(source) ?? "", directLoadCacheKey(source), payloadCacheKey(source, descriptor), ].join("\u0000"); } function viewerResourcePresentationKey( source: ViewerSource, descriptor: ViewerDescriptor, ) { return [ descriptor.category, descriptor.displayName, descriptor.fileName, descriptor.mimeType ?? "", downloadCacheKey(source), ].join("\u0000"); } function directLoadCacheKey(source: ViewerSource) { return source.kind === "url" ? source.url : ""; } function downloadCacheKey(source: ViewerSource) { if (source.kind === "text") return ""; return source.downloadUrl ?? ""; } function payloadCacheKey(source: ViewerSource, descriptor: ViewerDescriptor) { if (source.kind === "url") return ""; if (source.kind === "blob") return blobObjectKey(source.blob); return source.identityKey ? "" : descriptor.identityKey; } export function viewerResourceRenderKey(resource: ViewerResource): string { const load = [ resource.sourceKind, resource.identityKey, resource.mimeType ?? resource.content.mimeType ?? "", resource.content.directUrl ?? "", viewerContentRenderKey(resource.content), ].join("\u0000"); return [load, resource.keys.presentation].join("\u0000"); } export function viewerContentRenderKey(content: ViewerResourceContent): string { if (content.payload.kind === "text") return textPayloadKey(content.payload.text); return content.key; } function sourceMimeType(source: ViewerSource) { if (source.kind === "blob") return source.mimeType ?? source.blob.type; return source.mimeType; } function blobObjectKey(blob: Blob) { let key = blobObjectKeys.get(blob); if (!key) { nextBlobObjectKey += 1; key = `blob-object:${nextBlobObjectKey}`; blobObjectKeys.set(blob, key); } return key; } export function blobSource( bytes: Blob | ArrayBuffer | Uint8Array, metadata: { identityKey: string; fileName?: string; mimeType?: string; downloadUrl?: string; }, ): BlobViewerSource { const blob = bytes instanceof Blob ? bytes : new Blob( [bytes instanceof ArrayBuffer ? bytes : new Uint8Array(bytes)], { type: metadata.mimeType ?? "", }, ); return { kind: "blob", blob, fileName: metadata.fileName, mimeType: metadata.mimeType ?? blob.type, downloadUrl: metadata.downloadUrl, identityKey: metadata.identityKey, }; } function createUrlResource( source: UrlViewerSource, descriptor: ViewerDescriptor, keys: ViewerResourceKeys, ): ViewerResource { const content = internUrlResourceContent(source, keys); const originalDownload = createHrefDownloadAction({ id: "download-original", label: "Download", href: source.downloadUrl ?? source.url, fileName: descriptor.fileName, }); return resourceBase(source, descriptor, keys, { content, originalDownload }); } function internUrlResourceContent( source: UrlViewerSource, keys: ViewerResourceKeys, ): ViewerResourceContent { const cached = urlViewerResourceContentRegistry.get(keys.load); if (cached) return cached; const content = resourceContentBase(source, keys, { directUrl: source.url, payload: { kind: "url", url: source.url }, readBlob: async ({ cache, signal } = {}) => { const response = await fetchResource( source.url, cache ? { cache, signal } : { signal }, ); validateFullContentResponse(response); return readResponseBlob(response); }, readBytes: async ({ cache, signal } = {}) => { const response = await fetchResource( source.url, cache ? { cache, signal } : { signal }, ); validateFullContentResponse(response); return readResponseArrayBuffer(response); }, readText: async ({ cache, signal, maxBytes, maxLines } = {}) => { const response = await fetchResource( source.url, cache ? { cache, signal } : { signal }, ); return readBoundedResponseText(response, { maxBytes, maxLines }); }, readStream: async ({ cache, signal } = {}) => { const response = await fetchResource( source.url, cache ? { cache, signal } : { signal }, ); validateFullContentResponse(response); if (!response.body) { if (response.status === 204 || response.status === 205) { return emptyByteStream(); } throw new ResourceError({ kind: "unsupported_capability", message: "This response cannot be streamed.", }); } return response.body; }, readRange: async (range, { cache, signal } = {}) => { validateByteRange(range); const { start, end } = range; const init = { signal, headers: { Range: `bytes=${start}-${end}` }, }; const response = await fetchResource( source.url, cache ? { ...init, cache } : init, ); const buffer = await readResponseArrayBuffer(response); const contentRange = parseContentRange( response.headers.get("content-range"), ); validateUrlRangeResponse({ bufferLength: buffer.byteLength, contentRange, range, status: response.status, }); return { buffer, contentRange, isComplete: isByteRangeComplete({ bufferLength: buffer.byteLength, contentRange, requestedLength: end - start + 1, status: response.status, }), }; }, }); urlViewerResourceContentRegistry.set(keys.load, content); pruneUrlResourceContentRegistry(); return content; } function emptyByteStream() { return new ReadableStream({ start(controller) { controller.close(); }, }); } function createBlobResource( source: BlobViewerSource, descriptor: ViewerDescriptor, keys: ViewerResourceKeys, ): ViewerResource { const blob = source.blob; const content = internBlobResourceContent(source, keys); const originalDownload = source.downloadUrl ? createHrefDownloadAction({ id: "download-original", label: "Download", href: source.downloadUrl, fileName: descriptor.fileName, }) : createBlobDownloadAction({ id: "download-original", label: "Download", blob, fileName: descriptor.fileName, }); return resourceBase(source, descriptor, keys, { content, originalDownload }); } function internBlobResourceContent( source: BlobViewerSource, keys: ViewerResourceKeys, ): ViewerResourceContent { const blob = source.blob; let contents = blobViewerResourceContentRegistry.get(blob); if (!contents) { contents = new Map(); blobViewerResourceContentRegistry.set(blob, contents); } const cached = contents.get(keys.load); if (cached) return cached; const content = resourceContentBase(source, keys, { directUrl: null, payload: { kind: "blob", blob }, readBlob: async () => blob, readBytes: async () => blob.arrayBuffer(), readText: async ({ maxBytes, maxLines } = {}) => readBoundedBlobText(blob, { maxBytes, maxLines }), readStream: async () => blob.stream(), readRange: async (range) => { validateByteRange(range); const { start, end } = range; validateKnownByteRangeStart(start, blob.size); const rangeBlob = blob.slice(start, end + 1); return { buffer: await rangeBlob.arrayBuffer(), contentRange: { start, end: Math.min(end, blob.size - 1), total: blob.size, }, isComplete: end >= blob.size - 1, }; }, }); contents.set(keys.load, content); return content; } function createTextResource( source: TextSource, descriptor: ViewerDescriptor, keys: ViewerResourceKeys, ): ViewerResource { const content = internTextResourceContent(source, keys); const originalDownload = createTextDownloadAction({ id: "download-original", label: "Download", text: source.text, fileName: descriptor.fileName, mimeType: descriptor.mimeType, }); return resourceBase(source, descriptor, keys, { content, originalDownload }); } function internTextResourceContent( source: TextSource, keys: ViewerResourceKeys, ): ViewerResourceContent { const cached = textViewerResourceContentRegistry.get(keys.load); if (cached) return cached; const content = resourceContentBase(source, keys, { directUrl: null, payload: { kind: "text", text: source.text }, readBlob: async () => new Blob([source.text], { type: "text/plain;charset=utf-8", }), readBytes: async () => typedArrayBuffer(new TextEncoder().encode(source.text)), readText: async ({ maxBytes, maxLines } = {}) => readBoundedInlineText(source.text, { maxBytes, maxLines }), readStream: async () => new Blob([source.text]).stream(), readRange: async (range) => { validateByteRange(range); const { start, end } = range; const buffer = new TextEncoder().encode(source.text); validateKnownByteRangeStart(start, buffer.byteLength); const slice = buffer.slice(start, end + 1); return { buffer: typedArrayBuffer(slice), contentRange: { start, end: Math.min(end, buffer.byteLength - 1), total: buffer.byteLength, }, isComplete: end >= buffer.byteLength - 1, }; }, }); textViewerResourceContentRegistry.set(keys.load, content); pruneTextResourceContentRegistry(); return content; } function resourceBase( source: ViewerSource, descriptor: ViewerDescriptor, keys: ViewerResourceKeys, options: { content: ViewerResourceContent; originalDownload: ViewerDownloadAction; }, ): ViewerResource { const { content, originalDownload } = options; return Object.freeze({ descriptor, sourceKind: source.kind, keys, identityKey: descriptor.identityKey, fileName: descriptor.fileName, mimeType: descriptor.mimeType, content, originalDownload, }); } function resourceContentBase( source: ViewerSource, keys: ViewerResourceKeys, methods: Omit, ): ViewerResourceContent { return Object.freeze({ key: keys.load, sourceKind: source.kind, mimeType: sourceMimeType(source), ...methods, }); } function typedArrayBuffer(bytes: Uint8Array): ArrayBuffer { return bytes.buffer.slice( bytes.byteOffset, bytes.byteOffset + bytes.byteLength, ) as ArrayBuffer; } async function fetchResource( input: RequestInfo | URL, init?: RequestInit, ): Promise { let response: Response; try { response = await fetch(input, init); } catch (error) { if (isAbortError(error)) { throw new ResourceError({ kind: "aborted", message: "Loading was cancelled.", cause: error, }); } throw new ResourceError({ kind: "fetch_failed", message: "Could not fetch this resource.", cause: error, }); } if (!response.ok && response.status !== 206) { throw new ResourceError({ kind: "http_error", message: `Failed to load resource: ${response.status}`, status: response.status, }); } return response; } async function readBoundedResponseText( response: Response, bounds: { maxBytes?: number; maxLines?: number }, ) { validateFullContentResponse(response); const maxBytes = bounds.maxBytes; if ( isContentLengthOverLimit(response.headers.get("content-length"), maxBytes) ) { throw tooLarge("bytes"); } const body = response.body; if (!body) { const buffer = await readResponseArrayBuffer(response); if (maxBytes != null && buffer.byteLength > maxBytes) { throw tooLarge("bytes"); } const text = new TextDecoder().decode(buffer); assertLineLimit(text, bounds.maxLines); return text; } const reader = body.getReader(); const decoder = new TextDecoder(); const lineLimitTracker = createLineLimitTracker(bounds.maxLines); let receivedBytes = 0; let text = ""; while (true) { const { done, value } = await readResponseStreamChunk(reader); if (done) break; receivedBytes += value.byteLength; if (maxBytes != null && receivedBytes > maxBytes) { await cancelReaderSilently(reader); throw tooLarge("bytes"); } const chunkText = decoder.decode(value, { stream: true }); try { lineLimitTracker.push(chunkText); } catch (error) { await cancelReaderSilently(reader); throw error; } text += chunkText; } const finalText = decoder.decode(); lineLimitTracker.push(finalText); text += finalText; return text; } function isContentLengthOverLimit( contentLength: string | null, maxBytes: number | undefined, ) { if (maxBytes == null || contentLength == null) return false; const normalizedLength = contentLength.trim().replace(/^0+(?=\d)/, ""); if (!/^\d+$/.test(normalizedLength)) return false; const maxLength = String(maxBytes); return ( normalizedLength.length > maxLength.length || (normalizedLength.length === maxLength.length && normalizedLength > maxLength) ); } function validateFullContentResponse(response: Response) { if (response.status !== 206) return; const contentRange = parseContentRange(response.headers.get("content-range")); if ( contentRange?.total != null && contentRange.start === 0 && contentRange.end === contentRange.total - 1 ) { return; } throw new ResourceError({ kind: "partial_content", message: "Full response returned partial content.", status: response.status, }); } async function readResponseStreamChunk( reader: ReadableStreamDefaultReader, ) { try { return await reader.read(); } catch (error) { throw resourceReadError(error); } } async function readResponseArrayBuffer(response: Response) { try { return await response.arrayBuffer(); } catch (error) { throw resourceReadError(error); } } async function readResponseBlob(response: Response) { try { return await response.blob(); } catch (error) { throw resourceReadError(error); } } function resourceReadError(error: unknown) { if (isAbortError(error)) { return new ResourceError({ kind: "aborted", message: "Loading was cancelled.", cause: error, }); } return new ResourceError({ kind: "fetch_failed", message: "Could not read this resource.", cause: error, }); } async function readBoundedBlobText( blob: Blob, bounds: { maxBytes?: number; maxLines?: number }, ) { if (bounds.maxBytes != null && blob.size > bounds.maxBytes) { throw tooLarge("bytes"); } const text = await blob.text(); assertLineLimit(text, bounds.maxLines); return text; } function readBoundedInlineText( text: string, { maxBytes, maxLines }: { maxBytes?: number; maxLines?: number }, ) { // For inline sources the string *is* the resource, so its UTF-8 byte length // is the authoritative size to measure against maxBytes. if ( maxBytes != null && new TextEncoder().encode(text).byteLength > maxBytes ) { throw tooLarge("bytes"); } assertLineLimit(text, maxLines); return text; } // Used after a transferred-byte check has already enforced maxBytes (URL/blob). // Re-encoding the decoded text here would double-count: invalid UTF-8 decodes to // U+FFFD (3 bytes each), inflating the measured size past the real wire bytes // and falsely rejecting small resources as "too large". function assertLineLimit(text: string, maxLines: number | undefined) { if ( maxLines != null && text.split(TEXT_LINE_BREAK_PATTERN).length > maxLines ) { throw tooLarge("lines"); } } function tooLarge(reason: ResourceTooLargeReason) { return new ResourceError({ kind: "too_large", tooLargeReason: reason, message: `Resource exceeds ${reason} limit.`, }); } async function cancelReaderSilently( reader: ReadableStreamDefaultReader, ) { try { await reader.cancel(); } catch { // Preserve the user-facing load failure; cancellation is best-effort cleanup. } } function validateByteRange({ start, end }: ByteRange) { if ( !Number.isSafeInteger(start) || !Number.isSafeInteger(end) || start < 0 || end < start ) { throw new ResourceError({ kind: "invalid_range", message: "Byte range must use non-negative integer bounds.", }); } } function validateKnownByteRangeStart(start: number, total: number) { if (start > 0 && start >= total) { throw new ResourceError({ kind: "invalid_range", message: "Byte range starts past the available resource.", }); } } function validateUrlRangeResponse({ bufferLength, contentRange, range, status, }: { bufferLength: number; contentRange: ByteRangeResult["contentRange"]; range: ByteRange; status: number; }) { if (status === 200) { if (range.start !== 0 || bufferLength > range.end - range.start + 1) { throw new ResourceError({ kind: "invalid_range", message: "Full response does not match the requested byte range.", }); } return; } if (status !== 206) { throw new ResourceError({ kind: "invalid_range", message: "Range response must return full or partial content.", }); } if (!contentRange) { throw new ResourceError({ kind: "invalid_range", message: "Partial content response is missing a valid byte range.", }); } const declaredLength = contentRange.end - contentRange.start + 1; if ( contentRange.start !== range.start || contentRange.end < contentRange.start || contentRange.end > range.end || (contentRange.total != null && contentRange.end >= contentRange.total) || declaredLength !== bufferLength ) { throw new ResourceError({ kind: "invalid_range", message: "Response byte range does not match the requested range.", }); } } function isByteRangeComplete({ bufferLength, contentRange, requestedLength, status, }: { bufferLength: number; contentRange: ByteRangeResult["contentRange"]; requestedLength: number; status: number; }) { if (status === 200) return true; if (contentRange?.total != null) { if (contentRange.total <= 0) return true; return contentRange.end >= contentRange.total - 1; } if (contentRange) return false; return bufferLength < requestedLength; } function isStandaloneLineBreak(character: string) { const code = character.charCodeAt(0); return code === 0x0a || code === 0x2028 || code === 0x2029; } function createLineLimitTracker(maxLines: number | undefined) { let lineCount = 1; let previousWasCR = false; return { push(text: string) { if (maxLines == null || text.length === 0) return; for (const character of text) { if (previousWasCR) { previousWasCR = false; if (character === "\n") continue; } if (character === "\r") { lineCount += 1; previousWasCR = true; } else if (isStandaloneLineBreak(character)) { // LF, plus LINE/PARAGRAPH SEPARATOR (U+2028/U+2029); none pair with CR. lineCount += 1; } if (lineCount > maxLines) { throw tooLarge("lines"); } } }, }; } function parseContentRange(value: string | null) { if (!value) return undefined; const match = value.match(/^bytes\s+(\d+)-(\d+)\/(\d+|\*)\s*$/i); if (!match) return undefined; const start = parseContentRangeNumber(match[1]); const end = parseContentRangeNumber(match[2]); const total = match[3] === "*" ? null : parseContentRangeNumber(match[3] ?? ""); if (start == null || end == null || total === undefined) return undefined; return { start, end, total, }; } function parseContentRangeNumber(value: string) { const number = Number(value); return Number.isSafeInteger(number) ? number : undefined; } 54:Ta05,export type ViewerDownloadOrigin = "original" | "derived"; export type ViewerDownloadPayload = | { kind: "href"; href: string } | { kind: "blob"; blob: Blob } | { kind: "text"; text: string; mimeType?: string } | { kind: "none" }; export interface ViewerDownloadAction { id: string; label: string; fileName: string; origin: ViewerDownloadOrigin; isDisabled?: boolean; getPayload: (options?: { signal?: AbortSignal; }) => ViewerDownloadPayload | Promise; } export type ViewerDownloadErrorKind = | "disabled" | "aborted" | "payload_failed" | "unsupported"; export class ViewerDownloadError extends Error { readonly kind: ViewerDownloadErrorKind; readonly actionId: string; override readonly cause?: unknown; constructor({ actionId, kind, message, cause, }: { actionId: string; kind: ViewerDownloadErrorKind; message: string; cause?: unknown; }) { super(message); this.name = "ViewerDownloadError"; this.actionId = actionId; this.kind = kind; this.cause = cause; } } export function createHrefDownloadAction({ id, label = "Download", href, fileName, origin = "original", }: { id: string; label?: string; href: string; fileName: string; origin?: ViewerDownloadOrigin; }): ViewerDownloadAction { return { id, label, fileName, origin, getPayload: () => ({ kind: "href", href }), }; } export function createBlobDownloadAction({ id, label = "Download", blob, fileName, origin = "original", }: { id: string; label?: string; blob: Blob; fileName: string; origin?: ViewerDownloadOrigin; }): ViewerDownloadAction { return { id, label, fileName, origin, getPayload: () => ({ kind: "blob", blob }), }; } export function createTextDownloadAction({ id, label = "Download", text, fileName, mimeType, origin = "original", }: { id: string; label?: string; text: string; fileName: string; mimeType?: string; origin?: ViewerDownloadOrigin; }): ViewerDownloadAction { return { id, label, fileName, origin, getPayload: () => ({ kind: "text", text, mimeType }), }; } export function createDisabledDownloadAction({ id, label = "Download", fileName, origin = "original", }: { id: string; label?: string; fileName: string; origin?: ViewerDownloadOrigin; }): ViewerDownloadAction { return { id, label, fileName, origin, isDisabled: true, getPayload: () => ({ kind: "none" }), }; } 55:T14b6,export type FileCategory = | "pdf" | "docx" | "xlsx" | "pptx" | "csv" | "image" | "markdown" | "html" | "email" | "text" | "unsupported"; export type ViewerSource = UrlViewerSource | TextSource | BlobViewerSource; export interface UrlViewerSource { kind: "url"; url: string; fileName?: string; mimeType?: string; downloadUrl?: string; identityKey?: string; } export interface TextSource { kind: "text"; text: string; fileName?: string; mimeType?: string; identityKey?: string; } export interface BlobViewerSource { kind: "blob"; blob: Blob; identityKey: string; fileName?: string; mimeType?: string; downloadUrl?: string; } export interface ViewerDescriptor { source: ViewerSource; category: FileCategory; identityKey: string; displayName: string; fileName: string; mimeType?: string; } const EXTENSION_CATEGORY: Record = { pdf: "pdf", docx: "docx", xlsx: "xlsx", xls: "xlsx", xlsm: "xlsx", pptx: "pptx", csv: "csv", tsv: "csv", png: "image", jpg: "image", jpeg: "image", gif: "image", webp: "image", avif: "image", bmp: "image", svg: "image", ico: "image", tif: "image", tiff: "image", md: "markdown", markdown: "markdown", mdx: "text", html: "html", htm: "html", eml: "email", txt: "text", text: "text", log: "text", json: "text", jsonl: "text", json5: "text", ndjson: "text", xml: "text", yaml: "text", yml: "text", toml: "text", ini: "text", env: "text", js: "text", mjs: "text", cjs: "text", jsx: "text", ts: "text", tsx: "text", css: "text", scss: "text", less: "text", py: "text", rb: "text", go: "text", rs: "text", java: "text", kt: "text", c: "text", h: "text", cpp: "text", cc: "text", cs: "text", php: "text", sh: "text", bash: "text", zsh: "text", sql: "text", graphql: "text", proto: "text", lua: "text", r: "text", swift: "text", scala: "text", pl: "text", vue: "text", svelte: "text", }; export function extensionOf(name: string): string | null { const clean = name.split(/[?#]/)[0]; const base = clean.split("/").pop() ?? clean; const dot = base.lastIndexOf("."); return dot > 0 ? base.slice(dot + 1).toLowerCase() : null; } export function extractName(url: string): string { const clean = url.split(/[?#]/)[0]; return clean.split("/").pop() || "file"; } export function detectCategory( fileName: string, mimeType?: string, ): FileCategory { const ext = extensionOf(fileName); if (ext && EXTENSION_CATEGORY[ext]) return EXTENSION_CATEGORY[ext]; if (mimeType) { const fromMime = categoryFromMime(mimeType); if (fromMime) return fromMime; } return "unsupported"; } export function resolveViewerDescriptor({ source, category, }: { source: ViewerSource; category?: FileCategory; }): ViewerDescriptor { const resolvedMimeType = source.mimeType ?? (source.kind === "blob" && source.blob.type ? source.blob.type : undefined); const displayName = source.fileName ?? defaultDisplayName(source); const fileName = source.fileName ?? defaultFileName(source); const resolvedCategory = category ?? detectCategory(displayName, resolvedMimeType); return { source, category: resolvedCategory, identityKey: source.identityKey ?? defaultIdentityKey(source), displayName, fileName, mimeType: resolvedMimeType, }; } function categoryFromMime(mimeType: string): FileCategory | null { const mime = mimeType.toLowerCase().split(";")[0].trim(); if (mime === "application/pdf") return "pdf"; if (mime.includes("wordprocessingml")) return "docx"; if (mime.includes("spreadsheet") || mime.includes("ms-excel")) return "xlsx"; if (mime.includes("presentation") || mime.includes("ms-powerpoint")) { return "pptx"; } if (mime === "text/csv" || mime === "text/tab-separated-values") return "csv"; if (mime === "text/markdown") return "markdown"; if (mime === "text/html") return "html"; if (mime === "message/rfc822" || mime === "message/global") { return "email"; } if (mime.startsWith("image/")) return "image"; if (mime === "application/json" || mime === "application/xml") return "text"; if (mime.startsWith("text/")) return "text"; return null; } function defaultDisplayName(source: ViewerSource) { if (source.kind === "url") return source.url; if (source.kind === "text") return "text.txt"; return "file"; } function defaultFileName(source: ViewerSource) { if (source.kind === "url") return extractName(source.url); if (source.kind === "text") return "text.txt"; return "file"; } function defaultIdentityKey(source: ViewerSource) { if (source.kind === "url") return `url:${source.url}`; if (source.kind === "text") return textPayloadIdentityKey(source.text); return source.identityKey; } export function textPayloadIdentityKey(text: string) { return textPayloadKey(text); } export function textPayloadKey(text: string) { return `text:${text.length}:${hashString(text)}`; } function hashString(text: string) { let hash = 0x811c9dc5; for (let index = 0; index < text.length; index += 1) { hash ^= text.charCodeAt(index); hash = Math.imul(hash, 0x01000193); } return (hash >>> 0).toString(36); } 4e:["$","div",null,{"className":"mt-3 flex min-h-0 min-w-0 flex-1 flex-col gap-3","children":[["$","div",null,{"className":"flex shrink-0 items-start gap-3","children":[["$","div",null,{"className":"flex max-h-28 min-w-0 flex-1 flex-wrap items-center gap-2 overflow-y-auto","children":[["$","ul",null,{"className":"flex min-w-0 flex-wrap gap-2","aria-label":"Package dependencies","children":[["$","li","pdfjs-dist@5.4.296",{"className":"min-w-0 max-w-full","children":["$","a",null,{"href":"https://www.npmjs.com/package/pdfjs-dist","target":"_blank","rel":"noopener noreferrer","className":"flex max-w-full min-w-0 items-center gap-1.5 rounded-md border px-2 py-1.5 text-xs","children":[["$","svg",null,{"viewBox":"0 0 24 24","className":"size-3 shrink-0","children":["$","path",null,{"d":"M1.763 0C.786 0 0 .786 0 1.763v20.474C0 23.214.786 24 1.763 24h20.474c.977 0 1.763-.786 1.763-1.763V1.763C24 .786 23.214 0 22.237 0zM5.13 5.323l13.837.019-.009 13.836h-3.464l.01-10.382h-3.456L12.04 19.17H5.113z","fill":"currentColor"}]}],["$","span",null,{"className":"min-w-0 break-all text-xs font-medium","children":"pdfjs-dist@5.4.296"}]]}]}]]}],["$","$L4f",null,{"namespace":"@retab","registryDependencies":[]}]]}],null]}],["$","$L50",null,{"files":[{"path":"registry/new-york-v4/lib/pdf-document-types.ts","content":"export type PdfViewport = {\n width: number;\n height: number;\n};\n\nexport type PdfRenderTask = {\n promise: Promise;\n cancel: () => void;\n};\n\nexport type PdfPageProxy = {\n rotate?: number;\n getViewport: (options: { scale: number; rotation?: number }) => PdfViewport;\n render: (options: {\n canvas: HTMLCanvasElement;\n canvasContext: CanvasRenderingContext2D;\n viewport: PdfViewport;\n transform?: number[];\n }) => PdfRenderTask;\n};\n\nexport type PdfDocumentProxy = {\n numPages: number;\n getPage: (pageNumber: number) => Promise;\n destroy: () => Promise;\n};\n\nexport type PdfjsModule = {\n GlobalWorkerOptions: {\n workerSrc?: string;\n };\n getDocument: (source: string | { data: Uint8Array }) => {\n promise: Promise;\n };\n};\n","type":"registry:lib","target":"@lib/pdf-document-types.ts"},{"path":"registry/new-york-v4/lib/pdf-document-resource.ts","content":"$51","type":"registry:lib","target":"@lib/pdf-document-resource.ts"},{"path":"registry/new-york-v4/lib/viewer-errors.ts","content":"$52","type":"registry:lib","target":"@lib/viewer-errors.ts"},{"path":"registry/new-york-v4/lib/viewer-resource.ts","content":"$53","type":"registry:lib","target":"@lib/viewer-resource.ts"},{"path":"registry/new-york-v4/lib/viewer-download-actions.ts","content":"$54","type":"registry:lib","target":"@lib/viewer-download-actions.ts"},{"path":"registry/new-york-v4/lib/viewer-source.ts","content":"$55","type":"registry:lib","target":"@lib/viewer-source.ts"}],"className":"h-[70svh] min-h-80"}]]}]