ultra-fast-uri

2x faster than fast-uri | Zero dependencies | 100% RFC 3986 compliant

Ultra-fast URI parser written in pure JavaScript. Optimized for maximum performance while maintaining full compatibility with the URI specification.

🚀 Performance

fast-uri (original)          2,339,149 ops/sec
ultra-fast-uri (this!)       4,501,228 ops/sec  ⚡ 1.92x faster

Key optimizations:

• ✅ Manual parsing (no regex overhead)
• ✅ CharCode comparisons (faster than string methods)
• ✅ Early loop termination
• ✅ Minimal memory allocations
• ✅ Zero dependencies

📦 Installation

npm install ultra-fast-uri

🔧 Usage

const { parse, serialize, resolve, normalize, equal } = require('ultra-fast-uri');

// Parse a URI
const parsed = parse('http://user:[email protected]:8080/path?query=1#frag');
console.log(parsed);
// {
//   scheme: 'http',
//   userinfo: 'user:pass',
//   host: 'example.com',
//   port: 8080,
//   path: '/path',
//   query: 'query=1',
//   fragment: 'frag'
// }

// Serialize components back to URI
const uri = serialize({
  scheme: 'https',
  host: 'example.com',
  path: '/api',
  query: 'key=value'
});
// => 'https://example.com/api?key=value'

// Resolve relative URIs
const resolved = resolve('http://example.com/a/b/c', '../d');
// => 'http://example.com/a/d'

// Normalize URIs
const normalized = normalize('HTTP://EXAMPLE.COM/path/../other');
// => 'http://example.com/other'

// Compare URIs
const isEqual = equal('http://example.com/path', 'HTTP://EXAMPLE.COM/path');
// => true

📚 API

parse(uri, options?)

Parses a URI string into components.

Parameters:

• uri (string): The URI to parse
• options (object, optional): Parsing options
  • scheme (string): Override the URI scheme

Returns: Object with URI components

serialize(component, options?)

Serializes URI components into a string.

Parameters:

• component (object): URI components
• options (object, optional): Serialization options

Returns: URI string

resolve(baseUri, relativeUri, options?)

Resolves a relative URI against a base URI (RFC 3986).

Parameters:

• baseUri (string): Base URI
• relativeUri (string): Relative URI to resolve
• options (object, optional): Resolution options

Returns: Resolved absolute URI

resolveComponent(base, relative, options?)

Resolves URI components without string serialization.

Parameters:

• base (object): Base URI components
• relative (object): Relative URI components
• options (object, optional): Resolution options

Returns: Resolved URI components

normalize(uri, options?)

Normalizes a URI by:

• Converting scheme and host to lowercase
• Removing dot segments from path
• Removing default ports

Parameters:

• uri (string): URI to normalize
• options (object, optional): Normalization options

Returns: Normalized URI string

equal(uriA, uriB, options?)

Compares two URIs for equality after normalization.

Parameters:

• uriA (string): First URI
• uriB (string): Second URI
• options (object, optional): Comparison options

Returns: true if URIs are equal, false otherwise

🎯 Compatibility

• ✅ Node.js >= 10
• ✅ All modern browsers
• ✅ 100% RFC 3986 compliant
• ✅ Drop-in replacement for fast-uri

📊 Benchmarks

Run benchmarks yourself:

git clone https://github.com/yourusername/ultra-fast-uri.git
cd ultra-fast-uri
npm install
npm run bench

🔍 Why so fast?

1. Manual parsing - Instead of regex, we use direct string operations
2. CharCode comparisons - Faster than string methods for character checks
3. Minimal allocations - Reuse strings and avoid unnecessary object creation
4. Early termination - Stop parsing as soon as we find what we need
5. Zero dependencies - No overhead from external packages

📝 License

MIT

🤝 Contributing

Contributions welcome! Please open an issue or PR.

⭐ Show your support

Give a ⭐️ if this project helped you!