@helia/verified-fetch 4.0.1 → 4.0.3

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
@@ -41,7 +41,7 @@ export async function getContentType ({ bytes, path, contentTypeParser, log, def
       } else if (parsed != null) {
         contentType = parsed
       }
-      log.trace('contentTypeParser returned %s', contentType)
+      log.trace('contentTypeParser returned %s for file with name %s', contentType, fileName)
     } catch (err) {
       log.error('error parsing content type', err)
     }

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}`
+}

package/src/utils/parse-url-string.ts

@@ -1,77 +1,194 @@
-const URL_REGEX = /^(?<protocol>ip[fn]s):\/\/(?<cidOrPeerIdOrDnsLink>[^/?]+)\/?(?<path>[^?]*)\??(?<query>.*)$/
-const PATH_REGEX = /^\/(?<protocol>ip[fn]s)\/(?<cidOrPeerIdOrDnsLink>[^/?]+)\/?(?<path>[^?]*)\??(?<query>.*)$/
-const PATH_GATEWAY_REGEX = /^https?:\/\/(.*[^/])\/(?<protocol>ip[fn]s)\/(?<cidOrPeerIdOrDnsLink>[^/?]+)\/?(?<path>[^?]*)\??(?<query>.*)$/
-const SUBDOMAIN_GATEWAY_REGEX = /^https?:\/\/(?<cidOrPeerIdOrDnsLink>[^/?]+)\.(?<protocol>ip[fn]s)\.([^/?]+)\/?(?<path>[^?]*)\??(?<query>.*)$/
+import { InvalidParametersError } from '@libp2p/interface'
+import { decodeDNSLinkLabel, isInlinedDnsLink } from './dnslink-label.ts'
+import { ipfsPathToUrl, ipfsUrlToUrl } from './ipfs-path-to-url.ts'
 
-interface MatchUrlGroups {
+interface SubdomainMatchGroups {
   protocol: 'ipfs' | 'ipns'
   cidOrPeerIdOrDnsLink: string
-  path?: string
-  query?: string
 }
 
-function matchUrlGroupsGuard (groups?: null | { [key in string]: string; } | MatchUrlGroups): groups is MatchUrlGroups {
+const SUBDOMAIN_GATEWAY_REGEX = /^(?<cidOrPeerIdOrDnsLink>[^/?]+)\.(?<protocol>ip[fn]s)\.([^/?]+)$/
+
+function matchSubdomainGroupsGuard (groups?: null | { [key in string]: string; } | SubdomainMatchGroups): groups is SubdomainMatchGroups {
   const protocol = groups?.protocol
-  if (protocol == null) { return false }
+
+  if (protocol !== 'ipfs' && protocol !== 'ipns') {
+    return false
+  }
+
   const cidOrPeerIdOrDnsLink = groups?.cidOrPeerIdOrDnsLink
-  if (cidOrPeerIdOrDnsLink == null) { return false }
-  const path = groups?.path
-  const query = groups?.query
-
-  return ['ipns', 'ipfs'].includes(protocol) &&
-    typeof cidOrPeerIdOrDnsLink === 'string' &&
-    (path == null || typeof path === 'string') &&
-    (query == null || typeof query === 'string')
+
+  if (cidOrPeerIdOrDnsLink == null) {
+    return false
+  }
+
+  return true
 }
 
-// TODO: can this be replaced with `new URL`?
-export function matchURLString (urlString: string): MatchUrlGroups {
-  for (const pattern of [SUBDOMAIN_GATEWAY_REGEX, URL_REGEX, PATH_GATEWAY_REGEX, PATH_REGEX]) {
-    const match = urlString.match(pattern)
+export interface ParsedURL {
+  url: URL,
+  protocol: 'ipfs' | 'ipns'
+  cidOrPeerIdOrDnsLink: string
+  path: string[]
+  query: Record<string, any>
+  fragment: string
+}
 
-    if (matchUrlGroupsGuard(match?.groups)) {
-      const groups = match.groups satisfies MatchUrlGroups
+function toQuery (query?: URLSearchParams): Record<string, any> {
+  if (query == null) {
+    return {}
+  }
 
-      if (groups.path != null) {
-        groups.path = decodeURIComponent(groups.path)
-      }
+  const output: Record<string, any> = {}
 
-      // decode inline dnslink domain if present
-      if (pattern === SUBDOMAIN_GATEWAY_REGEX && groups.protocol === 'ipns' && isInlinedDnsLink(groups.cidOrPeerIdOrDnsLink)) {
-        groups.cidOrPeerIdOrDnsLink = dnsLinkLabelDecoder(groups.cidOrPeerIdOrDnsLink)
-      }
+  for (const [key, value] of query.entries()) {
+    output[key] = value
+
+    if (value === 'true') {
+      output[key] = true
+    }
 
-      return groups
+    if (value === 'false') {
+      output[key] = false
     }
   }
 
-  throw new TypeError(`Invalid URL: ${urlString}, please use ipfs://, ipns://, or gateway URLs only`)
+  return output
 }
 
-/**
- * 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.
- */
+function stripLeadingHash (pathname: string): string {
+  return stripLeading(pathname, '#')
+}
 
-// 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])?$/
+function stripLeading (str: string, char: string): string {
+  while (str.startsWith(char)) {
+    str = str.substring(1)
+  }
+
+  return str
+}
 
 /**
- * Checks if label looks like inlined DNSLink.
- * (https://specs.ipfs.tech/http-gateways/subdomain-gateway/#host-request-header)
+ * If the caller has passed a case-sensitive identifier (like a base58btc
+ * encoded CID or PeerId) in a case-insensitive location (like a subdomain),
+ * be nice and return the original identifier from the passed string
  */
-function isInlinedDnsLink (label: string): boolean {
-  return dnsLabelRegex.test(label) && label.includes('-') && !label.includes('.')
+function findOriginalCidOrPeer (needle: string, haystack: string): string {
+  const start = haystack.toLowerCase().indexOf(needle)
+
+  if (start === -1) {
+    return needle
+  }
+
+  return haystack.substring(start, start + needle.length)
+}
+
+function toUrl (urlString: string): URL {
+  // turn IPFS/IPNS path into gateway URL string
+  if (urlString.startsWith('/ipfs/') || urlString.startsWith('/ipns/')) {
+    urlString = ipfsPathToUrl(urlString)
+  }
+
+  // turn IPFS/IPNS URL into gateway URL string
+  if (urlString.startsWith('ipfs://') || urlString.startsWith('ipns://')) {
+    urlString = ipfsUrlToUrl(urlString)
+  }
+
+  if (urlString.startsWith('http://') || urlString.startsWith('https://')) {
+    return new URL(urlString)
+  }
+
+  throw new InvalidParametersError(`Invalid URL: ${urlString}`)
 }
 
 /**
- * DNSLink label decoding
- * - Every standalone - is replaced with .
- * - Every remaining -- is replaced with -
+ * Accepts the following url strings:
  *
- * @example en-wikipedia--on--ipfs-org.ipns.example.net -> example.net/ipns/en.wikipedia-on-ipfs.org
+ * - /ipfs/Qmfoo/path
+ * - /ipns/Qmfoo/path
+ * - ipfs://cid/path
+ * - ipns://name/path
+ * - http://cid.ipfs.example.com/path
+ * - http://name.ipns.example.com/path
+ * - http://example.com/ipfs/cid/path
+ * - http://example.com/ipns/name/path
  */
-function dnsLinkLabelDecoder (linkLabel: string): string {
-  return linkLabel.replace(/--/g, '%').replace(/-/g, '.').replace(/%/g, '-')
+export function parseURLString (urlString: string): ParsedURL {
+  // validate url
+  const url = toUrl(urlString)
+
+  // test for subdomain gateway URL
+  const subdomainMatch = url.hostname.match(SUBDOMAIN_GATEWAY_REGEX)
+
+  if (matchSubdomainGroupsGuard(subdomainMatch?.groups)) {
+    const groups = subdomainMatch.groups
+
+    if (groups.protocol === 'ipns' && isInlinedDnsLink(groups.cidOrPeerIdOrDnsLink)) {
+      // decode inline dnslink domain if present
+      groups.cidOrPeerIdOrDnsLink = decodeDNSLinkLabel(groups.cidOrPeerIdOrDnsLink)
+    }
+
+    const cidOrPeerIdOrDnsLink = findOriginalCidOrPeer(groups.cidOrPeerIdOrDnsLink, urlString)
+
+    // parse url as not http(s):// - this is necessary because URL makes
+    // `.pathname` default to `/` for http URLs, even if no trailing slash was
+    // present in the string URL and we need to be able to round-trip the user's
+    // input while also maintaining a sane canonical URL for the resource. Phew.
+    const wat = new URL(`not-${urlString}`)
+
+    return {
+      url: new URL(`${groups.protocol}://${cidOrPeerIdOrDnsLink}${wat.pathname}${url.search}${url.hash}`),
+      protocol: groups.protocol,
+      cidOrPeerIdOrDnsLink,
+      path: url.pathname.split('/')
+        .filter(str => str !== '')
+        .map(str => decodeURIComponent(str)),
+      query: toQuery(url.searchParams),
+      fragment: stripLeadingHash(url.hash)
+    }
+  }
+
+  // test for IPFS path gateway URL
+  if (url.pathname.startsWith('/ipfs/')) {
+    const parts = url.pathname.substring(6).split('/')
+    const cid = parts.shift()
+
+    if (cid == null) {
+      throw new InvalidParametersError(`Path gateway URL ${urlString} had no CID`)
+    }
+
+    return {
+      url: new URL(`ipfs://${cid}${url.pathname.replace(`/ipfs/${cid}`, '')}${url.search}${url.hash}`),
+      protocol: 'ipfs',
+      cidOrPeerIdOrDnsLink: cid,
+      path: parts
+        .filter(str => str !== '')
+        .map(str => decodeURIComponent(str)),
+      query: toQuery(url.searchParams),
+      fragment: stripLeadingHash(url.hash)
+    }
+  }
+
+  // test for IPNS path gateway URL
+  if (url.pathname.startsWith('/ipns/')) {
+    const parts = url.pathname.substring(6).split('/')
+    const name = parts.shift()
+
+    if (name == null) {
+      throw new InvalidParametersError(`Path gateway URL ${urlString} had no name`)
+    }
+
+    return {
+      url: new URL(`ipns://${name}${url.pathname.replace(`/ipns/${name}`, '')}${url.search}${url.hash}`),
+      protocol: 'ipns',
+      cidOrPeerIdOrDnsLink: name,
+      path: parts
+        .filter(str => str !== '')
+        .map(str => decodeURIComponent(str)),
+      query: toQuery(url.searchParams),
+      fragment: stripLeadingHash(url.hash)
+    }
+  }
+
+  throw new TypeError(`Invalid URL: ${urlString}, please use ipfs://, ipns://, or gateway URLs only`)
 }

package/src/utils/resource-to-cache-key.ts

@@ -1,5 +1,5 @@
 import { CID } from 'multiformats/cid'
-import { matchURLString } from './parse-url-string.js'
+import { parseURLString } from './parse-url-string.js'
 
 /**
  * Takes a resource and returns a session cache key as an IPFS or IPNS path with
@@ -24,7 +24,7 @@ export function resourceToSessionCacheKey (url: string | CID): string {
     return `ipfs://${CID.parse(url.toString())}`
   } catch {}
 
-  const { protocol, cidOrPeerIdOrDnsLink } = matchURLString(url.toString())
+  const { protocol, cidOrPeerIdOrDnsLink } = parseURLString(url.toString())
 
   return `${protocol}://${cidOrPeerIdOrDnsLink}`
 }

package/src/utils/responses.ts

@@ -16,6 +16,12 @@ function setType (response: Response, value: 'basic' | 'cors' | 'error' | 'opaqu
 }
 
 function setUrl (response: Response, value: string): void {
+  const fragmentStart = value.indexOf('#')
+
+  if (fragmentStart > -1) {
+    value = value.substring(0, fragmentStart)
+  }
+
   setField(response, 'url', value)
 }
 

package/src/utils/walk-path.ts

@@ -52,7 +52,7 @@ export function isObjectNode (node: UnixFSEntry): node is ObjectNode {
  */
 export async function handlePathWalking ({ cid, path, resource, options, blockstore, log }: PluginContext & { blockstore: Blockstore, log: Logger }): Promise<PathWalkerResponse | Response> {
   try {
-    return await walkPath(blockstore, `${cid}/${path}`, options)
+    return await walkPath(blockstore, `${cid}/${path.join('/')}`, options)
   } catch (err: any) {
     if (options?.signal?.aborted) {
       throw new AbortError(options?.signal?.reason)