@helia/verified-fetch 0.0.0-a04e041 → 0.0.0-dc2e7a6

package/src/verified-fetch.ts

@@ -1,23 +1,18 @@
-import { car } from '@helia/car'
 import { ipns as heliaIpns, type IPNS } from '@helia/ipns'
 import { dnsJsonOverHttps } from '@helia/ipns/dns-resolvers'
 import { unixfs as heliaUnixFs, type UnixFS as HeliaUnixFs, type UnixFSStats } from '@helia/unixfs'
-import * as ipldDagCbor from '@ipld/dag-cbor'
-import * as ipldDagJson from '@ipld/dag-json'
+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 toBrowserReadableStream from 'it-to-browser-readablestream'
 import { code as jsonCode } from 'multiformats/codecs/json'
 import { code as rawCode } from 'multiformats/codecs/raw'
 import { identity } from 'multiformats/hashes/identity'
 import { CustomProgressEvent } from 'progress-events'
 import { dagCborToSafeJSON } from './utils/dag-cbor-to-safe-json.js'
-import { getContentDispositionFilename } from './utils/get-content-disposition-filename.js'
 import { getETag } from './utils/get-e-tag.js'
 import { getStreamFromAsyncIterable } from './utils/get-stream-from-async-iterable.js'
 import { parseResource } from './utils/parse-resource.js'
-import { notAcceptableResponse, notSupportedResponse, okResponse } from './utils/responses.js'
-import { selectOutputType, queryFormatToAcceptHeader } from './utils/select-output-type.js'
-import { walkPath } from './utils/walk-path.js'
+import { walkPath, type PathWalkerFn } from './utils/walk-path.js'
 import type { CIDDetail, ContentTypeParser, Resource, VerifiedFetchInit as VerifiedFetchOptions } from './index.js'
 import type { RequestFormatShorthand } from './types.js'
 import type { Helia } from '@helia/interface'
@@ -29,6 +24,7 @@ interface VerifiedFetchComponents {
   helia: Helia
   ipns?: IPNS
   unixfs?: HeliaUnixFs
+  pathWalker?: PathWalkerFn
 }
 
 /**
@@ -41,13 +37,8 @@ interface VerifiedFetchInit {
 interface FetchHandlerFunctionArg {
   cid: CID
   path: string
+  terminalElement?: UnixFSEntry
   options?: Omit<VerifiedFetchOptions, 'signal'> & AbortOptions
-
-  /**
-   * If present, the user has sent an accept header with this value - if the
-   * content cannot be represented in this format a 406 should be returned
-   */
-  accept?: string
 }
 
 interface FetchHandlerFunction {
@@ -69,48 +60,29 @@ function convertOptions (options?: VerifiedFetchOptions): (Omit<VerifiedFetchOpt
   }
 }
 
-/**
- * These are Accept header values that will cause content type sniffing to be
- * skipped and set to these values.
- */
-const RAW_HEADERS = [
-  'application/vnd.ipld.raw',
-  'application/octet-stream'
-]
-
-/**
- * if the user has specified an `Accept` header, and it's in our list of
- * allowable "raw" format headers, use that instead of detecting the content
- * type. This avoids the user from receiving something different when they
- * signal that they want to `Accept` a specific mime type.
- */
-function getOverridenRawContentType (headers?: HeadersInit): string | undefined {
-  const acceptHeader = new Headers(headers).get('accept') ?? ''
-
-  // e.g. "Accept: text/html, application/xhtml+xml, application/xml;q=0.9, image/webp, */*;q=0.8"
-  const acceptHeaders = acceptHeader.split(',')
-    .map(s => s.split(';')[0])
-    .map(s => s.trim())
-
-  for (const mimeType of acceptHeaders) {
-    if (mimeType === '*/*') {
-      return
-    }
+function okResponse (body?: BodyInit | null): Response {
+  return new Response(body, {
+    status: 200,
+    statusText: 'OK'
+  })
+}
 
-    if (RAW_HEADERS.includes(mimeType ?? '')) {
-      return mimeType
-    }
-  }
+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 pathWalker: PathWalkerFn
   private readonly log: Logger
   private readonly contentTypeParser: ContentTypeParser | undefined
 
-  constructor ({ helia, ipns, unixfs }: 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, {
@@ -120,128 +92,60 @@ export class VerifiedFetch {
       ]
     })
     this.unixfs = unixfs ?? heliaUnixFs(helia)
+    this.pathWalker = pathWalker ?? walkPath
     this.contentTypeParser = init?.contentTypeParser
     this.log.trace('created VerifiedFetch instance')
   }
 
-  /**
-   * Accepts an `ipns://...` URL as a string and returns a `Response` containing
-   * a raw IPNS record.
-   */
-  private async handleIPNSRecord (resource: string, opts?: VerifiedFetchOptions): Promise<Response> {
-    return notSupportedResponse('vnd.ipfs.ipns-record support is not implemented')
-  }
-
-  /**
-   * Accepts a `CID` and returns a `Response` with a body stream that is a CAR
-   * of the `DAG` referenced by the `CID`.
-   */
-  private async handleCar ({ cid, options }: FetchHandlerFunctionArg): Promise<Response> {
-    const c = car(this.helia)
-    const stream = toBrowserReadableStream(c.stream(cid, options))
-
-    const response = okResponse(stream)
-    response.headers.set('content-type', 'application/vnd.ipld.car; version=1')
-
+  // handle vnd.ipfs.ipns-record
+  private async handleIPNSRecord ({ cid, path, options }: FetchHandlerFunctionArg): Promise<Response> {
+    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
   }
 
-  /**
-   * Accepts a UnixFS `CID` and returns a `.tar` file containing the file or
-   * directory structure referenced by the `CID`.
-   */
-  private async handleTar ({ cid, path, options }: FetchHandlerFunctionArg): Promise<Response> {
-    if (cid.code !== dagPbCode) {
-      return notAcceptableResponse('only dag-pb CIDs can be returned in TAR files')
-    }
-
-    return notSupportedResponse('application/tar support is not implemented')
+  // handle vnd.ipld.car
+  private async handleIPLDCar ({ cid, path, options }: FetchHandlerFunctionArg): Promise<Response> {
+    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 handleJson ({ cid, path, accept, options }: FetchHandlerFunctionArg): Promise<Response> {
+  private async handleJson ({ cid, path, options }: FetchHandlerFunctionArg): Promise<Response> {
     this.log.trace('fetching %c/%s', cid, path)
-    const block = await this.helia.blockstore.get(cid, options)
-    let body: string | Uint8Array
-
-    if (accept === 'application/vnd.ipld.dag-cbor' || accept === 'application/cbor') {
-      try {
-        // if vnd.ipld.dag-cbor has been specified, convert to the format - note
-        // that this supports more data types than regular JSON, the content-type
-        // response header is set so the user knows to process it differently
-        const obj = ipldDagJson.decode(block)
-        body = ipldDagCbor.encode(obj)
-      } catch (err) {
-        this.log.error('could not transform %c to application/vnd.ipld.dag-cbor', err)
-        return notAcceptableResponse()
-      }
-    } else {
-      // skip decoding
-      body = block
-    }
-
-    const response = okResponse(body)
-    response.headers.set('content-type', accept ?? 'application/json')
+    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
+    })
+    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, accept, options }: FetchHandlerFunctionArg): Promise<Response> {
+  private async handleDagCbor ({ cid, path, options }: FetchHandlerFunctionArg): Promise<Response> {
     this.log.trace('fetching %c/%s', cid, path)
-
-    const block = await this.helia.blockstore.get(cid, options)
+    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
 
-    if (accept === 'application/octet-stream' || accept === 'application/vnd.ipld.dag-cbor' || accept === 'application/cbor') {
-      // skip decoding
+    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
-    } else if (accept === 'application/vnd.ipld.dag-json') {
-      try {
-        // if vnd.ipld.dag-json has been specified, convert to the format - note
-        // that this supports more data types than regular JSON, the content-type
-        // response header is set so the user knows to process it differently
-        const obj = ipldDagCbor.decode(block)
-        body = ipldDagJson.encode(obj)
-      } catch (err) {
-        this.log.error('could not transform %c to application/vnd.ipld.dag-json', err)
-        return notAcceptableResponse()
-      }
-    } else {
-      try {
-        body = dagCborToSafeJSON(block)
-      } catch (err) {
-        if (accept === 'application/json') {
-          this.log('could not decode DAG-CBOR as JSON-safe, but the client sent "Accept: application/json"', err)
-
-          return notAcceptableResponse()
-        }
-
-        this.log('could not decode DAG-CBOR as JSON-safe, falling back to `application/octet-stream`', err)
-        body = block
-      }
     }
 
     const response = okResponse(body)
-
-    if (accept == null) {
-      accept = body instanceof Uint8Array ? 'application/octet-stream' : 'application/json'
-    }
-
-    response.headers.set('content-type', accept)
-
+    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
   }
 
-  private async handleDagPb ({ cid, path, options }: FetchHandlerFunctionArg): Promise<Response> {
-    let terminalElement: UnixFSEntry | undefined
-    let ipfsRoots: CID[] | undefined
-
-    try {
-      const pathDetails = await walkPath(this.helia.blockstore, `${cid.toString()}/${path}`, options)
-      ipfsRoots = pathDetails.ipfsRoots
-      terminalElement = pathDetails.terminalElement
-    } catch (err) {
-      this.log.error('Error walking path %s', path, err)
-    }
-
+  private async handleDagPb ({ cid, path, options, terminalElement }: FetchHandlerFunctionArg): Promise<Response> {
+    this.log.trace('fetching %c/%s', cid, path)
     let resolvedCID = terminalElement?.cid ?? cid
     let stat: UnixFSStats
     if (terminalElement?.type === 'directory') {
@@ -250,6 +154,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, path: rootFilePath }))
         stat = await this.unixfs.stat(dirCid, {
           path: rootFilePath,
           signal: options?.signal,
@@ -267,6 +172,7 @@ export class VerifiedFetch {
       }
     }
 
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid: resolvedCID, path: '' }))
     const asyncIter = this.unixfs.cat(resolvedCID, {
       signal: options?.signal,
       onProgress: options?.onProgress
@@ -279,27 +185,19 @@ export class VerifiedFetch {
     const response = okResponse(stream)
     await this.setContentType(firstChunk, path, response)
 
-    if (ipfsRoots != null) {
-      response.headers.set('X-Ipfs-Roots', ipfsRoots.map(cid => cid.toV1().toString()).join(',')) // https://specs.ipfs.tech/http-gateways/path-gateway/#x-ipfs-roots-response-header
-    }
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid: resolvedCID, path: '' }))
 
     return response
   }
 
   private async handleRaw ({ cid, path, options }: FetchHandlerFunctionArg): Promise<Response> {
-    const result = await this.helia.blockstore.get(cid, options)
+    this.log.trace('fetching %c/%s', cid, path)
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { cid, path }))
+    const result = await this.helia.blockstore.get(cid)
     const response = okResponse(result)
+    await this.setContentType(result, path, response)
 
-    // if the user has specified an `Accept` header that corresponds to a raw
-    // type, honour that header, so for example they don't request
-    // `application/vnd.ipld.raw` but get `application/octet-stream`
-    const overriddenContentType = getOverridenRawContentType(options?.headers)
-    if (overriddenContentType != null) {
-      response.headers.set('content-type', overriddenContentType)
-    } else {
-      await this.setContentType(result, path, response)
-    }
-
+    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid, path }))
     return response
   }
 
@@ -330,112 +228,111 @@ export class VerifiedFetch {
   }
 
   /**
-   * If the user has not specified an Accept header or format query string arg,
-   * use the CID codec to choose an appropriate handler for the block data.
+   * Determines the format requested by the client, defaults to `null` if no format is requested.
+   *
+   * @see https://specs.ipfs.tech/http-gateways/path-gateway/#format-request-query-parameter
+   * @default 'raw'
+   */
+  private getFormat ({ headerFormat, queryFormat }: { headerFormat: string | null, queryFormat: RequestFormatShorthand | null }): RequestFormatShorthand | null {
+    const formatMap: Record<string, RequestFormatShorthand> = {
+      'vnd.ipld.raw': 'raw',
+      'vnd.ipld.car': 'car',
+      'application/x-tar': 'tar',
+      'application/vnd.ipld.dag-json': 'dag-json',
+      'application/vnd.ipld.dag-cbor': 'dag-cbor',
+      'application/json': 'json',
+      'application/cbor': 'cbor',
+      'vnd.ipfs.ipns-record': 'ipns-record'
+    }
+
+    if (headerFormat != null) {
+      for (const format in formatMap) {
+        if (headerFormat.includes(format)) {
+          return formatMap[format]
+        }
+      }
+    } else if (queryFormat != null) {
+      return queryFormat
+    }
+
+    return null
+  }
+
+  /**
+   * Map of format to specific handlers for that format.
+   * 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 () => notSupportedResponse('application/vnd.ipld.raw support is not implemented'),
+    car: this.handleIPLDCar,
+    'ipns-record': this.handleIPNSRecord,
+    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> = {
     [dagPbCode]: this.handleDagPb,
-    [ipldDagJson.code]: this.handleJson,
+    [dagJsonCode]: this.handleJson,
     [jsonCode]: this.handleJson,
-    [ipldDagCbor.code]: this.handleDagCbor,
+    [dagCborCode]: this.handleDagCbor,
     [rawCode]: this.handleRaw,
     [identity.code]: this.handleRaw
   }
 
   async fetch (resource: Resource, opts?: VerifiedFetchOptions): Promise<Response> {
-    this.log('fetch %s', resource)
-
     const options = convertOptions(opts)
+    const { path, query, ...rest } = await parseResource(resource, { ipns: this.ipns, logger: this.helia.logger }, options)
+    const cid = rest.cid
+    let response: Response | undefined
 
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:start', { resource }))
-
-    // resolve the CID/path from the requested resource
-    const { path, query, cid } = await parseResource(resource, { ipns: this.ipns, logger: this.helia.logger }, options)
+    const format = this.getFormat({ headerFormat: new Headers(options?.headers).get('accept'), queryFormat: query.format ?? null })
 
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:resolve', { cid, path }))
-
-    const requestHeaders = new Headers(options?.headers)
-    const incomingAcceptHeader = requestHeaders.get('accept')
-
-    if (incomingAcceptHeader != null) {
-      this.log('incoming accept header "%s"', incomingAcceptHeader)
-    }
+    if (format != null) {
+      // TODO: These should be handled last when they're returning something other than 501
+      const formatHandler = this.formatHandlers[format]
 
-    const queryFormatMapping = queryFormatToAcceptHeader(query.format)
+      if (formatHandler != null) {
+        response = await formatHandler.call(this, { cid, path, options })
 
-    if (query.format != null) {
-      this.log('incoming query format "%s", mapped to %s', query.format, queryFormatMapping)
+        if (response.status === 501) {
+          return response
+        }
+      }
     }
 
-    const acceptHeader = incomingAcceptHeader ?? queryFormatMapping
-    const accept = selectOutputType(cid, acceptHeader)
-    this.log('output type %s', accept)
+    let terminalElement: UnixFSEntry | undefined
+    let ipfsRoots: CID[] | undefined
 
-    if (acceptHeader != null && accept == null) {
-      return notAcceptableResponse()
+    try {
+      const pathDetails = await this.pathWalker(this.helia.blockstore, `${cid.toString()}/${path}`, options)
+      ipfsRoots = pathDetails.ipfsRoots
+      terminalElement = pathDetails.terminalElement
+    } catch (err) {
+      this.log.error('Error walking path %s', path, err)
+      // return new Response(`Error walking path: ${(err as Error).message}`, { status: 500 })
     }
 
-    let response: Response
-    let reqFormat: RequestFormatShorthand | undefined
-
-    if (accept === 'application/vnd.ipfs.ipns-record') {
-      // the user requested a raw IPNS record
-      reqFormat = 'ipns-record'
-      response = await this.handleIPNSRecord(resource.toString(), options)
-    } else if (accept === 'application/vnd.ipld.car') {
-      // the user requested a CAR file
-      reqFormat = 'car'
-      query.download = true
-      query.filename = query.filename ?? `${cid.toString()}.car`
-      response = await this.handleCar({ cid, path, options })
-    } else if (accept === 'application/vnd.ipld.raw') {
-      // the user requested a raw block
-      reqFormat = 'raw'
-      query.download = true
-      query.filename = query.filename ?? `${cid.toString()}.bin`
-      response = await this.handleRaw({ cid, path, options })
-    } else if (accept === 'application/x-tar') {
-      // the user requested a TAR file
-      reqFormat = 'tar'
-      response = await this.handleTar({ cid, path, options })
-    } else {
-      // derive the handler from the CID type
+    if (response == null) {
       const codecHandler = this.codecHandlers[cid.code]
 
-      if (codecHandler == null) {
+      if (codecHandler != null) {
+        response = await codecHandler.call(this, { cid, path, options, terminalElement })
+      } else {
         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 = await codecHandler.call(this, { cid, path, accept, options })
     }
 
-    response.headers.set('etag', getETag({ cid, reqFormat, weak: false }))
+    response.headers.set('etag', getETag({ cid, reqFormat: format ?? undefined, weak: false }))
     response.headers.set('cache-control', 'public, max-age=29030400, immutable')
-    // https://specs.ipfs.tech/http-gateways/path-gateway/#x-ipfs-path-response-header
-    response.headers.set('X-Ipfs-Path', resource.toString())
-
-    // set Content-Disposition header
-    let contentDisposition: string | undefined
-
-    // force download if requested
-    if (query.download === true) {
-      contentDisposition = 'attachment'
-    }
-
-    // override filename if requested
-    if (query.filename != null) {
-      if (contentDisposition == null) {
-        contentDisposition = 'inline'
-      }
-
-      contentDisposition = `${contentDisposition}; ${getContentDispositionFilename(query.filename)}`
-    }
+    response.headers.set('X-Ipfs-Path', resource.toString()) // https://specs.ipfs.tech/http-gateways/path-gateway/#x-ipfs-path-response-header
 
-    if (contentDisposition != null) {
-      response.headers.set('Content-Disposition', contentDisposition)
+    if (ipfsRoots != null) {
+      response.headers.set('X-Ipfs-Roots', ipfsRoots.map(cid => cid.toV1().toString()).join(',')) // https://specs.ipfs.tech/http-gateways/path-gateway/#x-ipfs-roots-response-header
     }
-
-    options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid, path }))
+    // response.headers.set('Content-Disposition', `TODO`) // https://specs.ipfs.tech/http-gateways/path-gateway/#content-disposition-response-header
 
     return response
   }

package/dist/src/utils/get-content-disposition-filename.d.ts

@@ -1,6 +0,0 @@
-/**
- * Takes a filename URL param and returns a string for use in a
- * `Content-Disposition` header
- */
-export declare function getContentDispositionFilename(filename: string): string;
-//# sourceMappingURL=get-content-disposition-filename.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"get-content-disposition-filename.d.ts","sourceRoot":"","sources":["../../../src/utils/get-content-disposition-filename.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,6BAA6B,CAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAQvE"}

package/dist/src/utils/get-content-disposition-filename.js

@@ -1,16 +0,0 @@
-/**
- * Takes a filename URL param and returns a string for use in a
- * `Content-Disposition` header
- */
-export function getContentDispositionFilename(filename) {
-    const asciiOnly = replaceNonAsciiCharacters(filename);
-    if (asciiOnly === filename) {
-        return `filename="${filename}"`;
-    }
-    return `filename="${asciiOnly}"; filename*=UTF-8''${encodeURIComponent(filename)}`;
-}
-function replaceNonAsciiCharacters(filename) {
-    // eslint-disable-next-line no-control-regex
-    return filename.replace(/[^\x00-\x7F]/g, '_');
-}
-//# sourceMappingURL=get-content-disposition-filename.js.map

package/dist/src/utils/get-content-disposition-filename.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-content-disposition-filename.js","sourceRoot":"","sources":["../../../src/utils/get-content-disposition-filename.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,UAAU,6BAA6B,CAAE,QAAgB;IAC7D,MAAM,SAAS,GAAG,yBAAyB,CAAC,QAAQ,CAAC,CAAA;IAErD,IAAI,SAAS,KAAK,QAAQ,EAAE,CAAC;QAC3B,OAAO,aAAa,QAAQ,GAAG,CAAA;IACjC,CAAC;IAED,OAAO,aAAa,SAAS,uBAAuB,kBAAkB,CAAC,QAAQ,CAAC,EAAE,CAAA;AACpF,CAAC;AAED,SAAS,yBAAyB,CAAE,QAAgB;IAClD,4CAA4C;IAC5C,OAAO,QAAQ,CAAC,OAAO,CAAC,eAAe,EAAE,GAAG,CAAC,CAAA;AAC/C,CAAC"}

package/dist/src/utils/responses.d.ts

@@ -1,4 +0,0 @@
-export declare function okResponse(body?: BodyInit | null): Response;
-export declare function notSupportedResponse(body?: BodyInit | null): Response;
-export declare function notAcceptableResponse(body?: BodyInit | null): Response;
-//# sourceMappingURL=responses.d.ts.map

package/dist/src/utils/responses.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"responses.d.ts","sourceRoot":"","sources":["../../../src/utils/responses.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,CAAE,IAAI,CAAC,EAAE,QAAQ,GAAG,IAAI,GAAG,QAAQ,CAK5D;AAED,wBAAgB,oBAAoB,CAAE,IAAI,CAAC,EAAE,QAAQ,GAAG,IAAI,GAAG,QAAQ,CAOtE;AAED,wBAAgB,qBAAqB,CAAE,IAAI,CAAC,EAAE,QAAQ,GAAG,IAAI,GAAG,QAAQ,CAKvE"}

package/dist/src/utils/responses.js

@@ -1,21 +0,0 @@
-export function okResponse(body) {
-    return new Response(body, {
-        status: 200,
-        statusText: 'OK'
-    });
-}
-export function notSupportedResponse(body) {
-    const response = new Response(body, {
-        status: 501,
-        statusText: '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;
-}
-export function notAcceptableResponse(body) {
-    return new Response(body, {
-        status: 406,
-        statusText: 'Not Acceptable'
-    });
-}
-//# sourceMappingURL=responses.js.map

package/dist/src/utils/responses.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"responses.js","sourceRoot":"","sources":["../../../src/utils/responses.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,UAAU,CAAE,IAAsB;IAChD,OAAO,IAAI,QAAQ,CAAC,IAAI,EAAE;QACxB,MAAM,EAAE,GAAG;QACX,UAAU,EAAE,IAAI;KACjB,CAAC,CAAA;AACJ,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAE,IAAsB;IAC1D,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,IAAI,EAAE;QAClC,MAAM,EAAE,GAAG;QACX,UAAU,EAAE,iBAAiB;KAC9B,CAAC,CAAA;IACF,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,wBAAwB,EAAE,SAAS,CAAC,CAAA,CAAC,iGAAiG;IAC3J,OAAO,QAAQ,CAAA;AACjB,CAAC;AAED,MAAM,UAAU,qBAAqB,CAAE,IAAsB;IAC3D,OAAO,IAAI,QAAQ,CAAC,IAAI,EAAE;QACxB,MAAM,EAAE,GAAG;QACX,UAAU,EAAE,gBAAgB;KAC7B,CAAC,CAAA;AACJ,CAAC"}

package/dist/src/utils/select-output-type.d.ts

@@ -1,12 +0,0 @@
-import type { RequestFormatShorthand } from '../types.js';
-import type { CID } from 'multiformats/cid';
-/**
- * Selects an output mime-type based on the CID and a passed `Accept` header
- */
-export declare function selectOutputType(cid: CID, accept?: string): string | undefined;
-/**
- * Converts a `format=...` query param to a mime type as would be found in the
- * `Accept` header, if a valid mapping is available
- */
-export declare function queryFormatToAcceptHeader(format?: RequestFormatShorthand): string | undefined;
-//# sourceMappingURL=select-output-type.d.ts.map

package/dist/src/utils/select-output-type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"select-output-type.d.ts","sourceRoot":"","sources":["../../../src/utils/select-output-type.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AACzD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAuD3C;;GAEG;AACH,wBAAgB,gBAAgB,CAAE,GAAG,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAM/E;AAuFD;;;GAGG;AACH,wBAAgB,yBAAyB,CAAE,MAAM,CAAC,EAAE,sBAAsB,GAAG,MAAM,GAAG,SAAS,CAI9F"}