@helia/verified-fetch 4.0.1 → 4.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helia/verified-fetch",
-  "version": "4.0.1",
+  "version": "4.0.2",
   "description": "A fetch-like API for obtaining verified & trustless IPFS content on the web",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/ipfs/helia-verified-fetch/tree/main/packages/verified-fetch#readme",
@@ -175,12 +175,12 @@
     "@ipld/dag-cbor": "^9.2.3",
     "@ipld/dag-json": "^10.2.4",
     "@ipld/dag-pb": "^4.1.5",
-    "@libp2p/interface": "^3.0.0",
-    "@libp2p/kad-dht": "^16.0.0",
-    "@libp2p/peer-id": "^6.0.0",
-    "@libp2p/utils": "^7.0.5",
-    "@libp2p/webrtc": "^6.0.0",
-    "@libp2p/websockets": "^10.0.0",
+    "@libp2p/interface": "^3.1.0",
+    "@libp2p/kad-dht": "^16.1.0",
+    "@libp2p/peer-id": "^6.0.4",
+    "@libp2p/utils": "^7.0.7",
+    "@libp2p/webrtc": "^6.0.8",
+    "@libp2p/websockets": "^10.1.0",
     "@multiformats/dns": "^1.0.6",
     "cborg": "^4.2.11",
     "file-type": "^21.0.0",
@@ -193,7 +193,7 @@
     "it-tar": "^6.0.5",
     "it-to-browser-readablestream": "^2.0.11",
     "it-to-buffer": "^4.0.9",
-    "libp2p": "^3.0.0",
+    "libp2p": "^3.1.0",
     "multiformats": "^13.3.6",
     "progress-events": "^1.0.1",
     "quick-lru": "^7.0.1"
@@ -204,8 +204,8 @@
     "@helia/http": "^3.0.5",
     "@helia/json": "^5.0.0",
     "@ipld/car": "^5.4.2",
-    "@libp2p/crypto": "^5.1.3",
-    "@libp2p/logger": "^6.0.0",
+    "@libp2p/crypto": "^5.1.13",
+    "@libp2p/logger": "^6.2.0",
     "@types/sinon": "^17.0.4",
     "aegir": "^47.0.24",
     "browser-readablestream-to-it": "^2.0.9",

package/src/index.ts

@@ -856,7 +856,7 @@ export interface ResourceDetail {
 
 export interface CIDDetail {
   cid: CID
-  path?: string
+  path?: string[]
 }
 
 export interface CIDDetailError extends CIDDetail {
@@ -1069,10 +1069,12 @@ export interface UrlQuery extends Record<string, string | unknown> {
 }
 
 export interface ResolveURLResult {
+  url: URL
   cid: CID
   protocol: string
   ttl: number
-  path: string
+  path: string[]
+  fragment: string
   query: UrlQuery
   ipfsPath: string
 }

package/src/plugins/plugin-handle-dag-cbor-html-preview.ts

@@ -98,7 +98,7 @@ export class DagCborHtmlPreviewPlugin extends BasePlugin {
     })
   }
 
-  getHtml ({ path, obj, cid }: { path?: string, obj: Record<string, any>, cid: CID }): string {
+  getHtml ({ path, obj, cid }: { path?: string[], obj: Record<string, any>, cid: CID }): string {
     const style = `
       :root {
         --sans-serif: "Plex", system-ui, -apple-system, Segoe UI, Roboto, Ubuntu, Cantarell, Noto Sans, sans-serif;
@@ -221,7 +221,7 @@ export class DagCborHtmlPreviewPlugin extends BasePlugin {
       <main>
         <header>
           <div><strong>CID: </strong> <code class="nowrap">${cid}</code></div>
-          <div><strong>Codec: </strong> ${this.valueHTML('dag-cbor (0x71)', null)}</div>
+          <div><strong>Codec: </strong> ${this.valueHTML('dag-cbor (0x71)', [])}</div>
         </header>
         <section class="container">
           <p>You can download this block as:</p>
@@ -242,7 +242,7 @@ export class DagCborHtmlPreviewPlugin extends BasePlugin {
   </html>`
   }
 
-  valueHTML (value: any, link: string | null): string {
+  valueHTML (value: any, link: string[]): string {
     let valueString: string
     const isALinkObject = isLink(value)
     if (!isALinkObject && typeof value !== 'string') {
@@ -259,11 +259,11 @@ export class DagCborHtmlPreviewPlugin extends BasePlugin {
     return valueCodeBlock
   }
 
-  private renderValue (key: string, value: any, currentPath: string): string {
+  private renderValue (key: string, value: any, currentPath: string[]): string {
     let rows = ''
     value.forEach((item: any, idx: number) => {
-      const itemPath = currentPath ? `${currentPath}/${key}/${idx}` : `${key}/${idx}`
-      rows += `<div>${this.valueHTML(idx, null)}</div>`
+      const itemPath = [...currentPath, key, idx.toString()]
+      rows += `<div>${this.valueHTML(idx, [])}</div>`
       if (isPrimitive(item)) {
         rows += `<div>${this.valueHTML(item, itemPath)}</div>`
       } else {
@@ -275,7 +275,7 @@ export class DagCborHtmlPreviewPlugin extends BasePlugin {
     return rows
   }
 
-  renderRows (obj: Record<string, any>, currentPath: string = ''): string {
+  renderRows (obj: Record<string, any>, currentPath: string[] = []): string {
     let rows = ''
     for (const [key, value] of Object.entries(obj)) {
       if (Array.isArray(value)) {
@@ -284,7 +284,7 @@ export class DagCborHtmlPreviewPlugin extends BasePlugin {
         rows += this.renderValue(key, value, currentPath)
         rows += '</div>'
       } else {
-        const valuePath = currentPath ? `${currentPath}/${key}` : key
+        const valuePath = [...currentPath, key]
         rows += `<div>${key}</div><div>${this.valueHTML(value, valuePath)}</div>`
       }
     }

package/src/plugins/plugin-handle-dag-pb.ts

@@ -40,23 +40,25 @@ export class DagPbPlugin extends BasePlugin {
    * @see https://specs.ipfs.tech/http-gateways/path-gateway/#use-in-directory-url-normalization
    */
   getRedirectUrl (context: PluginContext): string | null {
-    const { resource, path } = context
-    const redirectCheckNeeded = path === '' ? !resource.toString().endsWith('/') : !path.endsWith('/')
-    if (redirectCheckNeeded) {
-      try {
-        const url = new URL(resource.toString())
-        if (url.pathname.endsWith('/')) {
-          // url already has a trailing slash
-          return null
-        }
-        // make sure we append slash to end of the path
-        url.pathname = `${url.pathname}/`
-        return url.toString()
-      } catch (err: any) {
-        // resource is likely a CID
-        return `${resource.toString()}/`
-      }
+    const { resource, url, isDirectory } = context
+
+    let uri: URL
+
+    try {
+      // try the requested resource
+      uri = new URL(resource)
+    } catch {
+      // fall back to the canonical URL
+      uri = url
     }
+
+    // directories must be requested with a trailing slash
+    if (isDirectory && !uri.pathname.endsWith('/')) {
+      // make sure we append slash to end of the path
+      uri.pathname += '/'
+      return uri.toString()
+    }
+
     return null
   }
 
@@ -65,7 +67,7 @@ export class DagPbPlugin extends BasePlugin {
     const { contentTypeParser, helia, getBlockstore } = this.pluginOptions
     const log = this.log
     let resource = context.resource
-    let path = context.path
+    const path = context.path
 
     let redirected = false
 
@@ -75,8 +77,9 @@ export class DagPbPlugin extends BasePlugin {
     let resolvedCID = terminalElement.cid
     const fs = unixfs({ ...helia, blockstore: getBlockstore(context.cid, context.resource, options?.session ?? true, options) })
 
+    context.isDirectory = terminalElement?.type === 'directory'
+
     if (terminalElement?.type === 'directory') {
-      const dirCid = terminalElement.cid
       const redirectUrl = this.getRedirectUrl(context)
 
       if (redirectUrl != null) {
@@ -95,7 +98,9 @@ export class DagPbPlugin extends BasePlugin {
         redirected = true
       }
 
+      const dirCid = terminalElement.cid
       const rootFilePath = 'index.html'
+
       try {
         log.trace('found directory at %c/%s, looking for index.html', cid, path)
 
@@ -105,7 +110,6 @@ export class DagPbPlugin extends BasePlugin {
         }))
 
         log.trace('found root file at %c/%s with cid %c', dirCid, rootFilePath, entry.cid)
-        path = rootFilePath
         resolvedCID = entry.cid
       } catch (err: any) {
         if (options?.signal?.aborted) {
@@ -126,7 +130,7 @@ export class DagPbPlugin extends BasePlugin {
         // dir-index-html plugin or dir-index-json (future idea?) plugin should handle this
         return null
       } finally {
-        options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid: dirCid, path: rootFilePath }))
+        options?.onProgress?.(new CustomProgressEvent<CIDDetail>('verified-fetch:request:end', { cid: dirCid, path: [rootFilePath] }))
       }
     }
 
@@ -157,13 +161,13 @@ export class DagPbPlugin extends BasePlugin {
         })
         log('got async iterator for %c/%s', cid, path)
 
-        const streamAndFirstChunk = await context.serverTiming.time('stream-and-chunk', '', getStreamFromAsyncIterable(asyncIter, path, this.pluginOptions.logger, {
+        const streamAndFirstChunk = await context.serverTiming.time('stream-and-chunk', '', getStreamFromAsyncIterable(asyncIter, {
           onProgress: options?.onProgress,
           signal: options?.signal
         }))
         const stream = streamAndFirstChunk.stream
         firstChunk = streamAndFirstChunk.firstChunk
-        contentType = await context.serverTiming.time('get-content-type', '', getContentType({ filename: query.filename, bytes: firstChunk, path, contentTypeParser, log }))
+        contentType = await context.serverTiming.time('get-content-type', '', getContentType({ path, filename: query.filename, bytes: firstChunk, contentTypeParser, log }))
 
         byteRangeContext.setBody(stream)
       }
@@ -207,7 +211,7 @@ export class DagPbPlugin extends BasePlugin {
       length: 8192
     })
 
-    const { firstChunk } = await getStreamFromAsyncIterable(asyncIter, path ?? '', this.pluginOptions.logger, {
+    const { firstChunk } = await getStreamFromAsyncIterable(asyncIter, {
       onProgress: options?.onProgress,
       signal: options?.signal
     })

package/src/plugins/plugin-handle-ipns-record.ts

@@ -13,7 +13,7 @@ export class IpnsRecordPlugin extends BasePlugin {
   readonly id = 'ipns-record-plugin'
   readonly codes = []
 
-  canHandle ({ resource, accept, query, path, byteRangeContext }: PluginContext): boolean {
+  canHandle ({ accept, query, byteRangeContext }: PluginContext): boolean {
     if (byteRangeContext == null) {
       return false
     }
@@ -26,7 +26,7 @@ export class IpnsRecordPlugin extends BasePlugin {
     const { ipnsResolver } = this.pluginOptions
     context.reqFormat = 'ipns-record'
 
-    if (path !== '' || !(resource.startsWith('ipns://') || resource.includes('.ipns.') || resource.includes('/ipns/'))) {
+    if (path.length > 0 || !(resource.startsWith('ipns://') || resource.includes('.ipns.') || resource.includes('/ipns/'))) {
       this.log.error('invalid request for IPNS name "%s" and path "%s"', resource, path)
       return badRequestResponse(resource, new Error('Invalid IPNS name'))
     }

package/src/plugins/plugin-handle-raw.ts

@@ -70,7 +70,7 @@ export class RawPlugin extends BasePlugin {
       log.trace('did not set content disposition, raw block will display inline')
     }
 
-    if (path !== '' && cid.code === rawCode) {
+    if (path.length > 0 && cid.code === rawCode) {
       log.trace('404-ing raw codec request for %c/%s', cid, path)
       return notFoundResponse(resource)
     }

package/src/plugins/types.ts

@@ -1,4 +1,4 @@
-import type { ResolveURLResult, UrlQuery, VerifiedFetchInit, ContentTypeParser, RequestFormatShorthand } from '../index.js'
+import type { ResolveURLResult, VerifiedFetchInit, ContentTypeParser, RequestFormatShorthand } from '../index.js'
 import type { ByteRangeContext } from '../utils/byte-range-context.js'
 import type { AcceptHeader } from '../utils/select-output-type.ts'
 import type { ServerTiming } from '../utils/server-timing.ts'
@@ -31,8 +31,6 @@ export interface PluginOptions {
  * - Ephemeral: Typically discarded once fetch(...) completes.
  */
 export interface PluginContext extends ResolveURLResult {
-  readonly cid: CID
-  readonly path: string
   readonly resource: string
   readonly accept?: AcceptHeader
 
@@ -52,7 +50,6 @@ export interface PluginContext extends ResolveURLResult {
   directoryEntries?: UnixFSEntry[]
   reqFormat?: RequestFormatShorthand
   pathDetails?: PathWalkerResponse
-  query: UrlQuery
 
   /**
    * ByteRangeContext contains information about the size of the content and range requests.

package/src/url-resolver.ts

@@ -1,7 +1,8 @@
 import { peerIdFromCID, peerIdFromString } from '@libp2p/peer-id'
 import { CID } from 'multiformats/cid'
-import { matchURLString } from './utils/parse-url-string.ts'
+import { parseURLString } from './utils/parse-url-string.ts'
 import type { ResolveURLOptions, ResolveURLResult, Resource, URLResolver as URLResolverInterface } from './index.ts'
+import type { ParsedURL } from './utils/parse-url-string.ts'
 import type { ServerTiming } from './utils/server-timing.ts'
 import type { DNSLink } from '@helia/dnslink'
 import type { IPNSResolver } from '@helia/ipns'
@@ -15,29 +16,6 @@ export interface URLResolverComponents {
   timing: ServerTiming
 }
 
-function toQuery (query?: string): Record<string, any> {
-  if (query == null) {
-    return {}
-  }
-
-  const params = new URLSearchParams(query)
-  const output: Record<string, any> = {}
-
-  for (const [key, value] of params.entries()) {
-    output[key] = value
-
-    if (value === 'true') {
-      output[key] = true
-    }
-
-    if (value === 'false') {
-      output[key] = false
-    }
-  }
-
-  return output
-}
-
 export class URLResolver implements URLResolverInterface {
   private readonly components: URLResolverComponents
 
@@ -53,56 +31,60 @@ export class URLResolver implements URLResolverInterface {
     const cid = CID.asCID(resource)
 
     if (cid != null) {
-      return this.resolveCIDResource(cid, '', {}, options)
+      return this.resolveCIDResource(cid, {
+        url: new URL(`ipfs://${cid}`)
+      }, options)
     }
 
     throw new TypeError(`Invalid resource. Cannot determine CID from resource: ${resource}`)
   }
 
   async parseUrlString (urlString: string, options: ResolveURLOptions = {}): Promise<ResolveURLResult> {
-    const { protocol, cidOrPeerIdOrDnsLink, path, query } = matchURLString(urlString)
+    const result = parseURLString(urlString)
 
-    if (protocol === 'ipfs') {
-      const cid = CID.parse(cidOrPeerIdOrDnsLink)
+    if (result.protocol === 'ipfs') {
+      const cid = CID.parse(result.cidOrPeerIdOrDnsLink)
 
-      return this.resolveCIDResource(cid, path ?? '', toQuery(query), options)
+      return this.resolveCIDResource(cid, result, options)
     }
 
-    if (protocol === 'ipns') {
+    if (result.protocol === 'ipns') {
       // try to parse target as peer id
       let peerId: PeerId
 
       try {
-        peerId = peerIdFromString(cidOrPeerIdOrDnsLink)
+        peerId = peerIdFromString(result.cidOrPeerIdOrDnsLink)
       } catch {
         // fall back to DNSLink (e.g. /ipns/example.com)
-        return this.resolveDNSLink(cidOrPeerIdOrDnsLink, path ?? '', toQuery(query), options)
+        return this.resolveDNSLink(result.cidOrPeerIdOrDnsLink, result, options)
       }
 
       // parse multihash from string (e.g. /ipns/QmFoo...)
-      return this.resolveIPNSName(cidOrPeerIdOrDnsLink, peerId, path ?? '', toQuery(query), options)
+      return this.resolveIPNSName(result.cidOrPeerIdOrDnsLink, peerId, result, options)
     }
 
     throw new TypeError(`Invalid resource. Cannot determine CID from resource: ${urlString}`)
   }
 
-  async resolveCIDResource (cid: CID, path: string, query: Record<string, any>, options: ResolveURLOptions = {}): Promise<ResolveURLResult> {
+  async resolveCIDResource (cid: CID, parsed: Partial<ParsedURL> & Pick<ParsedURL, 'url'>, options: ResolveURLOptions = {}): Promise<ResolveURLResult> {
     if (cid.code === CODEC_LIBP2P_KEY) {
       // special case - peer id encoded as a CID
-      return this.resolveIPNSName(cid.toString(), peerIdFromCID(cid), path, query, options)
+      return this.resolveIPNSName(cid.toString(), peerIdFromCID(cid), parsed, options)
     }
 
     return {
+      url: parsed.url,
       cid,
       protocol: 'ipfs',
-      query,
-      path,
+      query: parsed.query ?? {},
+      path: parsed.path ?? [],
+      fragment: parsed.fragment ?? '',
       ttl: 29030400, // 1 year for ipfs content
-      ipfsPath: `/ipfs/${cid}${path === '' ? '' : `/${path}`}`
+      ipfsPath: `/ipfs/${cid}${parsed.url.pathname}`
     }
   }
 
-  async resolveDNSLink (domain: string, path: string, query: Record<string, any>, options?: ResolveURLOptions): Promise<ResolveURLResult> {
+  async resolveDNSLink (domain: string, parsed: ParsedURL, options?: ResolveURLOptions): Promise<ResolveURLResult> {
     const results = await this.components.timing.time('dnsLink.resolve', `Resolve DNSLink ${domain}`, this.components.dnsLink.resolve(domain, options))
     const result = results?.[0]
 
@@ -112,7 +94,7 @@ export class URLResolver implements URLResolverInterface {
 
     // dnslink resolved to IPNS name
     if (result.namespace === 'ipns') {
-      return this.resolveIPNSName(domain, result.peerId, path, query, options)
+      return this.resolveIPNSName(domain, result.peerId, parsed, options)
     }
 
     // dnslink resolved to CID
@@ -122,38 +104,37 @@ export class URLResolver implements URLResolverInterface {
     }
 
     return {
+      url: parsed.url,
       cid: result.cid,
-      path: concatPaths(result.path, path),
+      path: concatPaths(...(result.path ?? '').split('/'), ...(parsed.path ?? [])),
+      fragment: parsed.fragment,
       // dnslink is mutable so return 'ipns' protocol so we do not include immutable in cache-control header
       protocol: 'ipns',
       ttl: result.answer.TTL,
-      query,
-      ipfsPath: `/ipns/${domain}${path === '' ? '' : `/${path}`}`
+      query: parsed.query,
+      ipfsPath: `/ipns/${domain}${parsed.url.pathname}`
     }
   }
 
-  async resolveIPNSName (resource: string, key: PeerId, path: string, query: Record<string, any>, options?: AbortOptions): Promise<ResolveURLResult> {
+  async resolveIPNSName (resource: string, key: PeerId, parsed: Partial<ParsedURL> & Pick<ParsedURL, 'url'>, options?: AbortOptions): Promise<ResolveURLResult> {
     const result = await this.components.timing.time('ipns.resolve', `Resolve IPNS name ${key}`, this.components.ipnsResolver.resolve(key, options))
 
     return {
+      url: parsed.url,
       cid: result.cid,
-      path: concatPaths(result.path, path),
-      query,
+      path: concatPaths(...(result.path ?? '').split('/'), ...(parsed.path ?? [])),
+      query: parsed.query ?? {},
+      fragment: parsed.fragment ?? '',
       protocol: 'ipns',
       // IPNS ttl is in nanoseconds, convert to seconds
       ttl: Number((result.record.ttl ?? 0n) / BigInt(1e9)),
-      ipfsPath: `/ipns/${resource}${path === '' ? '' : `/${path}`}`
+      ipfsPath: `/ipns/${resource}${parsed.url.pathname}`
     }
   }
 }
 
-function concatPaths (...paths: Array<string | undefined>): string {
-  return `${
-    paths
-      .filter(p => p != null && p !== '')
-      .join('/')
-      .replaceAll(/(\/+)/g, '/')
-      .replace(/^(\/)+/, '')
-      .replace(/(\/)+$/, '/')
-  }`
+function concatPaths (...paths: Array<string | undefined>): string[] {
+  // @ts-expect-error undefined is filtered out
+  return paths
+    .filter(p => p != null && p !== '')
 }

package/src/utils/dnslink-label.ts

@@ -0,0 +1,38 @@
+/**
+ * For DNSLink see https://specs.ipfs.tech/http-gateways/subdomain-gateway/#host-request-header
+ * DNSLink names include . which means they must be inlined into a single DNS label to provide unique origin and work with wildcard TLS certificates.
+ */
+
+// DNS label can have up to 63 characters, consisting of alphanumeric
+// characters or hyphens -, but it must not start or end with a hyphen.
+const dnsLabelRegex = /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/
+
+/**
+ * Checks if label looks like inlined DNSLink.
+ * (https://specs.ipfs.tech/http-gateways/subdomain-gateway/#host-request-header)
+ */
+export function isInlinedDnsLink (label: string): boolean {
+  return dnsLabelRegex.test(label) && label.includes('-') && !label.includes('.')
+}
+
+/**
+ * DNSLink label decoding
+ * - Every standalone - is replaced with .
+ * - Every remaining -- is replaced with -
+ *
+ * @example en-wikipedia--on--ipfs-org -> en.wikipedia-on-ipfs.org
+ */
+export function decodeDNSLinkLabel (label: string): string {
+  return label.replace(/--/g, '%').replace(/-/g, '.').replace(/%/g, '-')
+}
+
+/**
+ * DNSLink label encoding
+ * - Every - is replaced with --
+ * - Every . is replaced with -
+ *
+ * @example en.wikipedia-on-ipfs.org -> en-wikipedia--on--ipfs-org
+ */
+export function encodeDNSLinkLabel (name: string): string {
+  return name.replace(/-/g, '--').replace(/\./g, '-')
+}

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

@@ -5,7 +5,7 @@ import type { Logger } from '@libp2p/interface'
 
 export interface GetContentTypeOptions {
   bytes: Uint8Array
-  path?: string
+  path?: string[]
   defaultContentType?: string
   contentTypeParser?: ContentTypeParser
   log: Logger
@@ -25,7 +25,7 @@ export async function getContentType ({ bytes, path, contentTypeParser, log, def
     try {
       let fileName
       if (filenameParam == null) {
-        fileName = path?.split('/').pop()?.trim()
+        fileName = path?.[path.length - 1]?.trim()
         fileName = (fileName === '' || fileName?.split('.').length === 1) ? undefined : fileName
       } else {
         fileName = filenameParam

package/src/utils/get-stream-from-async-iterable.ts

@@ -2,18 +2,15 @@ import { AbortError } from '@libp2p/interface'
 import { CustomProgressEvent } from 'progress-events'
 import { NoContentError } from '../errors.js'
 import type { VerifiedFetchInit } from '../index.js'
-import type { Logger } from '@libp2p/interface'
 
 /**
  * Converts an async iterator of Uint8Array bytes to a stream and returns the first chunk of bytes
  */
-export async function getStreamFromAsyncIterable (iterator: AsyncIterable<Uint8Array>, path: string, logger: Logger, options?: Pick<VerifiedFetchInit, 'onProgress' | 'signal'>): Promise<{ stream: ReadableStream<Uint8Array>, firstChunk: Uint8Array }> {
-  const log = logger.newScope('get-stream-from-async-iterable')
+export async function getStreamFromAsyncIterable (iterator: AsyncIterable<Uint8Array>, options?: Pick<VerifiedFetchInit, 'onProgress' | 'signal'>): Promise<{ stream: ReadableStream<Uint8Array>, firstChunk: Uint8Array }> {
   const reader = iterator[Symbol.asyncIterator]()
   const { value: firstChunk, done } = await reader.next()
 
   if (done === true) {
-    log.error('no content found for path "%s"', path)
     throw new NoContentError()
   }
 

package/src/utils/handle-redirects.ts

@@ -1,5 +1,5 @@
 import { SubdomainNotSupportedError } from '../errors.js'
-import { matchURLString } from './parse-url-string.js'
+import { parseURLString } from './parse-url-string.js'
 import { movedPermanentlyResponse } from './responses.js'
 import type { VerifiedFetchInit, Resource } from '../index.js'
 import type { AbortOptions, ComponentLogger } from '@libp2p/interface'
@@ -47,7 +47,7 @@ export async function getRedirectResponse ({ resource, options, logger, cid, fet
   // if x-forwarded-host is passed, we need to set the location header to the
   // subdomain so that the browser can redirect to the correct subdomain
   try {
-    const urlParts = matchURLString(resource)
+    const urlParts = parseURLString(resource)
     const reqUrl = new URL(resource)
     const actualHost = forwardedHost ?? reqUrl.host
     const subdomainUrl = new URL(reqUrl)

package/src/utils/ipfs-path-to-url.ts

@@ -0,0 +1,54 @@
+import { InvalidParametersError } from '@libp2p/interface'
+
+/**
+ * Turns an IPFS or IPNS path into a HTTP URL. Path gateway syntax is used to
+ * preserve any case sensitivity
+ *
+ * - `/ipfs/cid` -> `https://example.org/ipfs/cid`
+ * - `/ipns/name` -> `https://example.org/ipns/name`
+ */
+export function ipfsPathToUrl (path: string): string {
+  if (!path.startsWith('/ipfs/') && !path.startsWith('/ipns/')) {
+    throw new InvalidParametersError(`Path ${path} did not start with /ipfs/ or /ipns/`)
+  }
+
+  // trim fragment
+  const fragmentIndex = path.indexOf('#')
+  let fragment = ''
+
+  if (fragmentIndex > -1) {
+    fragment = path.substring(fragmentIndex)
+    path = path.substring(0, fragmentIndex)
+  }
+
+  // trim query
+  const queryIndex = path.indexOf('?')
+  let query = ''
+
+  if (queryIndex > -1) {
+    query = path.substring(queryIndex)
+    path = path.substring(0, queryIndex)
+  }
+
+  const type = path.substring(1, 5)
+  const rest = path.substring(6)
+
+  return `https://example.org/${type}/${rest}${query}${fragment}`
+}
+
+/**
+ * Turns an IPFS or IPNS URL into a HTTP URL. Path gateway syntax is used to
+ * preserve and case sensitivity
+ *
+ * `ipfs://cid` -> `https://example.org/ipfs/cid`
+ */
+export function ipfsUrlToUrl (url: string): string {
+  if (!url.startsWith('ipfs://') && !url.startsWith('ipns://')) {
+    throw new InvalidParametersError(`URL ${url} did not start with ipfs:// or ipns://`)
+  }
+
+  const type = url.substring(0, 4)
+  const rest = url.substring(7)
+
+  return `https://example.org/${type}/${rest}`
+}