4f: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"] 50: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; } 51: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" }), }; } 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: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":[null,["$","$L4f",null,{"files":[{"path":"registry/new-york-v4/lib/docx-document-resource.ts","content":"import type {\n ViewerContentBytes,\n ViewerContentIdentity,\n} from \"@/lib/viewer-resource\";\n\nconst bufferCache = new Map>();\n\nexport function getDocxDocumentResource(\n content: ViewerContentBytes,\n options: { retainRejected?: boolean } = {},\n): Promise {\n const loadKey = content.key;\n const cached = bufferCache.get(loadKey);\n if (cached) return cached;\n\n const promise = readDocxBytes(content).catch((error) => {\n if (!options.retainRejected && bufferCache.get(loadKey) === promise) {\n bufferCache.delete(loadKey);\n }\n throw error;\n });\n bufferCache.set(loadKey, promise);\n return promise;\n}\n\nexport function clearDocxDocumentResource(content: ViewerContentIdentity) {\n bufferCache.delete(content.key);\n}\n\nexport function resetDocxDocumentResourceCacheForTests() {\n bufferCache.clear();\n}\n\nfunction readDocxBytes(content: ViewerContentBytes): Promise {\n return content.readBytes();\n}\n","type":"registry:lib","target":"@lib/docx-document-resource.ts"},{"path":"registry/new-york-v4/lib/viewer-resource.ts","content":"$50","type":"registry:lib","target":"@lib/viewer-resource.ts"},{"path":"registry/new-york-v4/lib/viewer-download-actions.ts","content":"$51","type":"registry:lib","target":"@lib/viewer-download-actions.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-source.ts","content":"$53","type":"registry:lib","target":"@lib/viewer-source.ts"}],"className":"h-[70svh] min-h-80"}]]}]