@helia/verified-fetch 0.0.0-5c0c39c → 0.0.0-754c7af

package/src/verified-fetch.ts

@@ -1,19 +1,18 @@
-import { dagCbor as heliaDagCbor, type DAGCBOR } from '@helia/dag-cbor'
-import { dagJson as heliaDagJson, type DAGJSON } from '@helia/dag-json'
 import { ipns as heliaIpns, type IPNS } from '@helia/ipns'
 import { dnsJsonOverHttps } from '@helia/ipns/dns-resolvers'
-import { json as heliaJson, type JSON } from '@helia/json'
 import { unixfs as heliaUnixFs, type UnixFS as HeliaUnixFs, type UnixFSStats } from '@helia/unixfs'
 import { code as dagCborCode } from '@ipld/dag-cbor'
 import { code as dagJsonCode } from '@ipld/dag-json'
 import { code as dagPbCode } from '@ipld/dag-pb'
 import { code as jsonCode } from 'multiformats/codecs/json'
-import { decode, code as rawCode } from 'multiformats/codecs/raw'
+import { code as rawCode } from 'multiformats/codecs/raw'
+import { identity } from 'multiformats/hashes/identity'
 import { CustomProgressEvent } from 'progress-events'
-import { getStreamAndContentType } from './utils/get-stream-and-content-type.js'
+import { dagCborToSafeJSON } from './utils/dag-cbor-to-safe-json.js'
+import { getStreamFromAsyncIterable } from './utils/get-stream-from-async-iterable.js'
 import { parseResource } from './utils/parse-resource.js'
 import { walkPath, type PathWalkerFn } from './utils/walk-path.js'
-import type { CIDDetail, Resource, VerifiedFetchInit as VerifiedFetchOptions } from './index.js'
+import type { CIDDetail, ContentTypeParser, Resource, VerifiedFetchInit as VerifiedFetchOptions } from './index.js'
 import type { Helia } from '@helia/interface'
 import type { AbortOptions, Logger } from '@libp2p/interface'
 import type { UnixFSEntry } from 'ipfs-unixfs-exporter'
@@ -23,18 +22,14 @@ interface VerifiedFetchComponents {
   helia: Helia
   ipns?: IPNS
   unixfs?: HeliaUnixFs
-  dagJson?: DAGJSON
-  json?: JSON
-  dagCbor?: DAGCBOR
   pathWalker?: PathWalkerFn
 }
 
 /**
  * Potential future options for the VerifiedFetch constructor.
  */
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
 interface VerifiedFetchInit {
-
+  contentTypeParser?: ContentTypeParser
 }
 
 interface FetchHandlerFunctionArg {
@@ -63,17 +58,29 @@ function convertOptions (options?: VerifiedFetchOptions): (Omit<VerifiedFetchOpt
   }
 }
 
+function okResponse (body?: BodyInit | null): Response {
+  return new Response(body, {
+    status: 200,
+    statusText: 'OK'
+  })
+}
+
+function notSupportedResponse (body?: BodyInit | null): Response {
+  return new Response(body, {
+    status: 501,
+    statusText: 'Not Implemented'
+  })
+}
+
 export class VerifiedFetch {
   private readonly helia: Helia
   private readonly ipns: IPNS
   private readonly unixfs: HeliaUnixFs
-  private readonly dagJson: DAGJSON
-  private readonly dagCbor: DAGCBOR
-  private readonly json: JSON
   private readonly pathWalker: PathWalkerFn
   private readonly log: Logger
+  private readonly contentTypeParser: ContentTypeParser | undefined
 
-  constructor ({ helia, ipns, unixfs, dagJson, json, dagCbor, pathWalker }: VerifiedFetchComponents, init?: VerifiedFetchInit) {
+  constructor ({ helia, ipns, unixfs, pathWalker }: VerifiedFetchComponents, init?: VerifiedFetchInit) {
     this.helia = helia
     this.log = helia.logger.forComponent('helia:verified-fetch')
     this.ipns = ipns ?? heliaIpns(helia, {
@@ -83,63 +90,55 @@ export class VerifiedFetch {
       ]
     })
     this.unixfs = unixfs ?? heliaUnixFs(helia)
-    this.dagJson = dagJson ?? heliaDagJson(helia)
-    this.json = json ?? heliaJson(helia)
-    this.dagCbor = dagCbor ?? heliaDagCbor(helia)
     this.pathWalker = pathWalker ?? walkPath
+    this.contentTypeParser = init?.contentTypeParser
     this.log.trace('created VerifiedFetch instance')
   }
 
   // handle vnd.ipfs.ipns-record
   private async handleIPNSRecord ({ cid, path, options }: FetchHandlerFunctionArg): Promise<Response> {
-    const response = new Response('vnd.ipfs.ipns-record support is not implemented', { status: 501 })
+    const response = notSupportedResponse('vnd.ipfs.ipns-record support is not implemented')
     response.headers.set('X-Content-Type-Options', 'nosniff') // see https://specs.ipfs.tech/http-gateways/path-gateway/#x-content-type-options-response-header
     return response
   }
 
   // handle vnd.ipld.car
   private async handleIPLDCar ({ cid, path, options }: FetchHandlerFunctionArg): Promise<Response> {
-    const response = new Response('vnd.ipld.car support is not implemented', { status: 501 })
+    const response = notSupportedResponse('vnd.ipld.car support is not implemented')
     response.headers.set('X-Content-Type-Options', 'nosniff') // see https://specs.ipfs.tech/http-gateways/path-gateway/#x-content-type-options-response-header
     return response
   }
 
-  private async handleDagJson ({ cid, path, options }: FetchHandlerFunctionArg): Promise<Response> {
-    this.log.trace('fetching %c/%s', cid, path)
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid: cid.toString(), path }))
-    const result = await this.dagJson.get(cid, {
-      signal: options?.signal,
-      onProgress: options?.onProgress
-    })
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid: cid.toString(), path }))
-    const response = new Response(JSON.stringify(result), { status: 200 })
-    response.headers.set('content-type', 'application/json')
-    return response
-  }
-
   private async handleJson ({ cid, path, options }: FetchHandlerFunctionArg): Promise<Response> {
     this.log.trace('fetching %c/%s', cid, path)
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid: cid.toString(), path }))
-    const result: Record<any, any> = await this.json.get(cid, {
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid, path }))
+    const result = await this.helia.blockstore.get(cid, {
       signal: options?.signal,
       onProgress: options?.onProgress
     })
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid: cid.toString(), path }))
-    const response = new Response(JSON.stringify(result), { status: 200 })
+    const response = okResponse(result)
     response.headers.set('content-type', 'application/json')
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid, path }))
     return response
   }
 
   private async handleDagCbor ({ cid, path, options }: FetchHandlerFunctionArg): Promise<Response> {
     this.log.trace('fetching %c/%s', cid, path)
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid: cid.toString(), path }))
-    const result = await this.dagCbor.get(cid, {
-      signal: options?.signal,
-      onProgress: options?.onProgress
-    })
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid: cid.toString(), path }))
-    const response = new Response(JSON.stringify(result), { status: 200 })
-    response.headers.set('content-type', 'application/json')
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid, path }))
+    // return body as binary
+    const block = await this.helia.blockstore.get(cid)
+    let body: string | Uint8Array
+
+    try {
+      body = dagCborToSafeJSON(block)
+    } catch (err) {
+      this.log('could not decode DAG-CBOR as JSON-safe, falling back to `application/octet-stream`', err)
+      body = block
+    }
+
+    const response = okResponse(body)
+    response.headers.set('content-type', body instanceof Uint8Array ? 'application/octet-stream' : 'application/json')
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid, path }))
     return response
   }
 
@@ -153,7 +152,7 @@ export class VerifiedFetch {
       const rootFilePath = 'index.html'
       try {
         this.log.trace('found directory at %c/%s, looking for index.html', cid, path)
-        options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid: dirCid.toString(), path: rootFilePath }))
+        options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid: dirCid, path: rootFilePath }))
         stat = await this.unixfs.stat(dirCid, {
           path: rootFilePath,
           signal: options?.signal,
@@ -165,39 +164,67 @@ export class VerifiedFetch {
         // terminalElement = stat
       } catch (err: any) {
         this.log('error loading path %c/%s', dirCid, rootFilePath, err)
-        return new Response('Unable to find index.html for directory at given path. Support for directories with implicit root is not implemented', { status: 501 })
+        return notSupportedResponse('Unable to find index.html for directory at given path. Support for directories with implicit root is not implemented')
       } finally {
-        options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid: dirCid.toString(), path: rootFilePath }))
+        options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid: dirCid, path: rootFilePath }))
       }
     }
 
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid: resolvedCID.toString(), path: '' }))
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid: resolvedCID, path: '' }))
     const asyncIter = this.unixfs.cat(resolvedCID, {
       signal: options?.signal,
       onProgress: options?.onProgress
     })
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid: resolvedCID.toString(), path: '' }))
     this.log('got async iterator for %c/%s', cid, path)
 
-    const { contentType, stream } = await getStreamAndContentType(asyncIter, path ?? '', this.helia.logger, {
+    const { stream, firstChunk } = await getStreamFromAsyncIterable(asyncIter, path ?? '', this.helia.logger, {
       onProgress: options?.onProgress
     })
-    const response = new Response(stream, { status: 200 })
-    response.headers.set('content-type', contentType)
+    const response = okResponse(stream)
+    await this.setContentType(firstChunk, path, response)
+
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid: resolvedCID, path: '' }))
 
     return response
   }
 
   private async handleRaw ({ cid, path, options }: FetchHandlerFunctionArg): Promise<Response> {
     this.log.trace('fetching %c/%s', cid, path)
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid: cid.toString(), path }))
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid, path }))
     const result = await this.helia.blockstore.get(cid)
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid: cid.toString(), path }))
-    const response = new Response(decode(result), { status: 200 })
-    response.headers.set('content-type', 'application/octet-stream')
+    const response = okResponse(result)
+    await this.setContentType(result, path, response)
+
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid, path }))
     return response
   }
 
+  private async setContentType (bytes: Uint8Array, path: string, response: Response): Promise<void> {
+    let contentType = 'application/octet-stream'
+
+    if (this.contentTypeParser != null) {
+      try {
+        let fileName = path.split('/').pop()?.trim()
+        fileName = fileName === '' ? undefined : fileName
+        const parsed = this.contentTypeParser(bytes, fileName)
+
+        if (isPromise(parsed)) {
+          const result = await parsed
+
+          if (result != null) {
+            contentType = result
+          }
+        } else if (parsed != null) {
+          contentType = parsed
+        }
+      } catch (err) {
+        this.log.error('Error parsing content type', err)
+      }
+    }
+
+    response.headers.set('content-type', contentType)
+  }
+
   /**
    * Determines the format requested by the client, defaults to `null` if no format is requested.
    *
@@ -234,22 +261,23 @@ export class VerifiedFetch {
    * These format handlers should adjust the response headers as specified in https://specs.ipfs.tech/http-gateways/path-gateway/#response-headers
    */
   private readonly formatHandlers: Record<string, FetchHandlerFunction> = {
-    raw: async () => new Response('application/vnd.ipld.raw support is not implemented', { status: 501 }),
+    raw: async () => notSupportedResponse('application/vnd.ipld.raw support is not implemented'),
     car: this.handleIPLDCar,
     'ipns-record': this.handleIPNSRecord,
-    tar: async () => new Response('application/x-tar support is not implemented', { status: 501 }),
-    'dag-json': async () => new Response('application/vnd.ipld.dag-json support is not implemented', { status: 501 }),
-    'dag-cbor': async () => new Response('application/vnd.ipld.dag-cbor support is not implemented', { status: 501 }),
-    json: async () => new Response('application/json support is not implemented', { status: 501 }),
-    cbor: async () => new Response('application/cbor support is not implemented', { status: 501 })
+    tar: async () => notSupportedResponse('application/x-tar support is not implemented'),
+    'dag-json': async () => notSupportedResponse('application/vnd.ipld.dag-json support is not implemented'),
+    'dag-cbor': async () => notSupportedResponse('application/vnd.ipld.dag-cbor support is not implemented'),
+    json: async () => notSupportedResponse('application/json support is not implemented'),
+    cbor: async () => notSupportedResponse('application/cbor support is not implemented')
   }
 
   private readonly codecHandlers: Record<number, FetchHandlerFunction> = {
-    [dagJsonCode]: this.handleDagJson,
     [dagPbCode]: this.handleDagPb,
+    [dagJsonCode]: this.handleJson,
     [jsonCode]: this.handleJson,
     [dagCborCode]: this.handleDagCbor,
-    [rawCode]: this.handleRaw
+    [rawCode]: this.handleRaw,
+    [identity.code]: this.handleRaw
   }
 
   async fetch (resource: Resource, opts?: VerifiedFetchOptions): Promise<Response> {
@@ -291,12 +319,12 @@ export class VerifiedFetch {
       if (codecHandler != null) {
         response = await codecHandler.call(this, { cid, path, options, terminalElement })
       } else {
-        return new Response(`Support for codec with code ${cid.code} is not yet implemented. Please open an issue at https://github.com/ipfs/helia/issues/new`, { status: 501 })
+        return notSupportedResponse(`Support for codec with code ${cid.code} is not yet implemented. Please open an issue at https://github.com/ipfs/helia/issues/new`)
       }
     }
 
     response.headers.set('etag', cid.toString()) // https://specs.ipfs.tech/http-gateways/path-gateway/#etag-response-header
-    response.headers.set('cache-cotrol', 'public, max-age=29030400, immutable')
+    response.headers.set('cache-control', 'public, max-age=29030400, immutable')
     response.headers.set('X-Ipfs-Path', resource.toString()) // https://specs.ipfs.tech/http-gateways/path-gateway/#x-ipfs-path-response-header
 
     if (ipfsRoots != null) {
@@ -321,3 +349,7 @@ export class VerifiedFetch {
     await this.helia.stop()
   }
 }
+
+function isPromise <T> (p?: any): p is Promise<T> {
+  return p?.then != null
+}

package/dist/src/utils/get-content-type.d.ts

@@ -1,11 +0,0 @@
-interface TestInput {
-    bytes: Uint8Array;
-    path: string;
-}
-export declare const DEFAULT_MIME_TYPE = "application/octet-stream";
-/**
- * Get the content type from the input based on the tests.
- */
-export declare function getContentType(input: TestInput): Promise<string>;
-export {};
-//# sourceMappingURL=get-content-type.d.ts.map

package/dist/src/utils/get-content-type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-content-type.d.ts","sourceRoot":"","sources":["../../../src/utils/get-content-type.ts"],"names":[],"mappings":"AAEA,UAAU,SAAS;IACjB,KAAK,EAAE,UAAU,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;CACb;AAID,eAAO,MAAM,iBAAiB,6BAA6B,CAAA;AAkC3D;;GAEG;AACH,wBAAsB,cAAc,CAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,CAQvE"}

package/dist/src/utils/get-content-type.js

@@ -1,43 +0,0 @@
-import mime from 'mime-types';
-export const DEFAULT_MIME_TYPE = 'application/octet-stream';
-const xmlRegex = /^(<\?xml[^>]+>)?[^<^\w]+<svg/ig;
-/**
- * Tests to determine the content type of the input.
- * The order is important on this one.
- */
-const tests = [
-    // svg
-    async ({ bytes }) => xmlRegex.test(new TextDecoder().decode(bytes.slice(0, 64)))
-        ? 'image/svg+xml'
-        : undefined,
-    // testing file-type from path
-    async ({ path }) => {
-        const mimeType = mime.lookup(path);
-        if (mimeType !== false) {
-            return mimeType;
-        }
-        return undefined;
-    }
-];
-const overrides = {
-    'video/quicktime': 'video/mp4'
-};
-/**
- * Override the content type based on overrides.
- */
-function overrideContentType(type) {
-    return overrides[type] ?? type;
-}
-/**
- * Get the content type from the input based on the tests.
- */
-export async function getContentType(input) {
-    for (const test of tests) {
-        const type = await test(input);
-        if (type !== undefined) {
-            return overrideContentType(type);
-        }
-    }
-    return DEFAULT_MIME_TYPE;
-}
-//# sourceMappingURL=get-content-type.js.map

package/dist/src/utils/get-content-type.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-content-type.js","sourceRoot":"","sources":["../../../src/utils/get-content-type.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,YAAY,CAAA;AAS7B,MAAM,CAAC,MAAM,iBAAiB,GAAG,0BAA0B,CAAA;AAE3D,MAAM,QAAQ,GAAG,gCAAgC,CAAA;AAEjD;;;GAGG;AACH,MAAM,KAAK,GAA4C;IACrD,MAAM;IACN,KAAK,EAAE,EAAE,KAAK,EAAE,EAAc,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC;QAC1F,CAAC,CAAC,eAAe;QACjB,CAAC,CAAC,SAAS;IACb,8BAA8B;IAC9B,KAAK,EAAE,EAAE,IAAI,EAAE,EAAc,EAAE;QAC7B,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;QAClC,IAAI,QAAQ,KAAK,KAAK,EAAE,CAAC;YACvB,OAAO,QAAQ,CAAA;QACjB,CAAC;QACD,OAAO,SAAS,CAAA;IAClB,CAAC;CACF,CAAA;AAED,MAAM,SAAS,GAA2B;IACxC,iBAAiB,EAAE,WAAW;CAC/B,CAAA;AAED;;GAEG;AACH,SAAS,mBAAmB,CAAE,IAAY;IACxC,OAAO,SAAS,CAAC,IAAI,CAAC,IAAI,IAAI,CAAA;AAChC,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAE,KAAgB;IACpD,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,CAAA;QAC9B,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,OAAO,mBAAmB,CAAC,IAAI,CAAC,CAAA;QAClC,CAAC;IACH,CAAC;IACD,OAAO,iBAAiB,CAAA;AAC1B,CAAC"}

package/dist/src/utils/get-stream-and-content-type.d.ts

@@ -1,10 +0,0 @@
-import type { VerifiedFetchInit } from '../index.js';
-import type { ComponentLogger } from '@libp2p/interface';
-/**
- * Converts an async iterator of Uint8Array bytes to a stream and attempts to determine the content type of those bytes.
- */
-export declare function getStreamAndContentType(iterator: AsyncIterable<Uint8Array>, path: string, logger: ComponentLogger, options?: Pick<VerifiedFetchInit, 'onProgress'>): Promise<{
-    contentType: string;
-    stream: ReadableStream<Uint8Array>;
-}>;
-//# sourceMappingURL=get-stream-and-content-type.d.ts.map

package/dist/src/utils/get-stream-and-content-type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-stream-and-content-type.d.ts","sourceRoot":"","sources":["../../../src/utils/get-stream-and-content-type.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AACpD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AAExD;;GAEG;AACH,wBAAsB,uBAAuB,CAAE,QAAQ,EAAE,aAAa,CAAC,UAAU,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,eAAe,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,iBAAiB,EAAE,YAAY,CAAC,GAAG,OAAO,CAAC;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,cAAc,CAAC,UAAU,CAAC,CAAA;CAAE,CAAC,CAmChP"}

package/dist/src/utils/get-stream-and-content-type.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-stream-and-content-type.js","sourceRoot":"","sources":["../../../src/utils/get-stream-and-content-type.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAA;AAItD;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAAE,QAAmC,EAAE,IAAY,EAAE,MAAuB,EAAE,OAA+C;IACxK,MAAM,GAAG,GAAG,MAAM,CAAC,YAAY,CAAC,kDAAkD,CAAC,CAAA;IACnF,MAAM,MAAM,GAAG,QAAQ,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE,CAAA;IAC/C,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,MAAM,MAAM,CAAC,IAAI,EAAE,CAAA;IAE3C,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;QAClB,GAAG,CAAC,KAAK,CAAC,2BAA2B,EAAE,IAAI,CAAC,CAAA;QAC5C,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAA;IACrC,CAAC;IAED,MAAM,WAAW,GAAG,MAAM,cAAc,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAA;IAChE,MAAM,MAAM,GAAG,IAAI,cAAc,CAAC;QAChC,KAAK,CAAC,KAAK,CAAE,UAAU;YACrB,yCAAyC;YACzC,OAAO,EAAE,UAAU,EAAE,CAAC,IAAI,mBAAmB,CAAO,uCAAuC,CAAC,CAAC,CAAA;YAC7F,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QAC3B,CAAC;QACD,KAAK,CAAC,IAAI,CAAE,UAAU;YACpB,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,MAAM,MAAM,CAAC,IAAI,EAAE,CAAA;YAE3C,IAAI,IAAI,KAAK,IAAI,EAAE,CAAC;gBAClB,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;oBAClB,OAAO,EAAE,UAAU,EAAE,CAAC,IAAI,mBAAmB,CAAO,uCAAuC,CAAC,CAAC,CAAA;oBAC7F,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;gBAC3B,CAAC;gBACD,UAAU,CAAC,KAAK,EAAE,CAAA;gBAClB,OAAM;YACR,CAAC;YAED,OAAO,EAAE,UAAU,EAAE,CAAC,IAAI,mBAAmB,CAAO,uCAAuC,CAAC,CAAC,CAAA;YAC7F,UAAU,CAAC,OAAO,CAAC,KAAK,CAAC,CAAA;QAC3B,CAAC;KACF,CAAC,CAAA;IAEF,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,CAAA;AAChC,CAAC"}

package/src/utils/get-content-type.ts

@@ -1,55 +0,0 @@
-import mime from 'mime-types'
-
-interface TestInput {
-  bytes: Uint8Array
-  path: string
-}
-
-type TestOutput = Promise<string | undefined>
-
-export const DEFAULT_MIME_TYPE = 'application/octet-stream'
-
-const xmlRegex = /^(<\?xml[^>]+>)?[^<^\w]+<svg/ig
-
-/**
- * Tests to determine the content type of the input.
- * The order is important on this one.
- */
-const tests: Array<(input: TestInput) => TestOutput> = [
-  // svg
-  async ({ bytes }): TestOutput => xmlRegex.test(new TextDecoder().decode(bytes.slice(0, 64)))
-    ? 'image/svg+xml'
-    : undefined,
-  // testing file-type from path
-  async ({ path }): TestOutput => {
-    const mimeType = mime.lookup(path)
-    if (mimeType !== false) {
-      return mimeType
-    }
-    return undefined
-  }
-]
-
-const overrides: Record<string, string> = {
-  'video/quicktime': 'video/mp4'
-}
-
-/**
- * Override the content type based on overrides.
- */
-function overrideContentType (type: string): string {
-  return overrides[type] ?? type
-}
-
-/**
- * Get the content type from the input based on the tests.
- */
-export async function getContentType (input: TestInput): Promise<string> {
-  for (const test of tests) {
-    const type = await test(input)
-    if (type !== undefined) {
-      return overrideContentType(type)
-    }
-  }
-  return DEFAULT_MIME_TYPE
-}