You've tried to visit a page that doesn't exist. Luckily this site - has other pages.
-If you were looking for something specific, try searching: +
+ You've tried to visit a page that doesn't exist. Luckily this site has + other pages. +
+
-
-
A Dart library for parsing, validating, manipulating, and converting -Internationalized Resource Identifiers (IRIs) based on RFC 3987.
-Internationalized Resource Identifiers (IRIs) extend the syntax of Uniform -Resource Identifiers (URIs) to support a wider range of characters from the -Universal Character Set (Unicode/ISO 10646). This is essential for representing -resource identifiers in languages that use characters outside the US-ASCII range.
-This package provides the IRI class to work with IRIs in Dart applications.
-It handles the necessary conversions between IRIs and standard URIs, including:
A pure Dart implementation of Internationalized Resource Identifiers (IRI) as defined in RFC 3987.
+This package provides an Iri class that acts as a Unicode-aware wrapper around Dart's native Uri class. It handles the mapping between IRIs and URIs, including automatic Punycode conversion for hostnames and UTF-8 percent-encoding for other components.
IRI objects from strings.scheme, host, path, query, fragment, userInfo, port.IRI object to a standard Dart Uri object, applying Punycode and percent-encoding according to RFC 3987 rules.Uri back into an IRI, decoding percent-encoded sequences where appropriate.. and .. segments).IRI objects based on their code point sequence (simple string comparison).。, ．, ｡) during parsing and conversion.mailto: IRIs, ensuring email domain parts are correctly Punycode-encoded.Uri class API, including resolve, resolveIri, and replace.Iri class is immutable and supports equality checks.Add the package to your pubspec.yaml:
While this package aims for high compatibility with RFC 3987, there are known areas where the current implementation deviates from the strict specification:
+Uri to an Iri, the package currently uses standard UTF-8 decoding. If a percent-encoded sequence is invalid UTF-8 (e.g., %FC), the implementation may throw a FormatException instead of preserving the percent-encoding as required by the RFC.U+202E) are prohibited from appearing directly in an IRI. Currently, these characters are decoded if present in a URI, whereas they should remain percent-encoded.These areas may be a part of future updates. For most common use cases involving standard Unicode text in paths and hosts, the package provides a robust experience.
+Add iri to your pubspec.yaml dependencies:
dependencies:
- iri: ^0.1.0
-Then, import the library in your Dart code:
-import 'package:iri/iri.dart';
+ iri: ^0.2.0
Here's a basic example demonstrating how to create an IRI and convert it to a Uri:
import 'package:iri/iri.dart';
void main() {
- // 1. Create an IRI from a string containing non-ASCII characters.
- // 例子 means "example" in Chinese.
- // The path contains 'ȧ' (U+0227 LATIN SMALL LETTER A WITH DOT ABOVE).
- final iri = IRI('https://例子.com/pȧth?q=1');
-
- // 2. Print the original IRI string representation.
- print('Original IRI: $iri');
- // Output: Original IRI: https://例子.com/pȧth?q=1
-
- // 3. Convert the IRI to its standard URI representation.
- // - The host (例子.com) is converted to Punycode (xn--fsqu00a.com).
- // - The non-ASCII path character 'ȧ' (UTF-8 bytes C8 A7) is percent-encoded (%C8%A7).
- final uri = iri.toUri();
- print('Converted URI: $uri');
- // Output: Converted URI: https://xn--fsqu00a.com/p%C8%A7th?q=1
+ // Parse an IRI with Unicode characters
+ final iri = Iri.parse('http://résumé.example.org/résumé');
- // 4. Access components (values are decoded for IRI representation).
- print('Scheme: ${iri.scheme}'); // Output: Scheme: https
- print('Host: ${iri.host}'); // Output: Host: 例子.com
- print('Path: ${iri.path}'); // Output: Path: /pȧth
- print('Query: ${iri.query}'); // Output: Query: q=1
+ print('IRI host: ${iri.host}'); // résumé.example.org
+ print('IRI path: ${iri.path}'); // /résumé
- // 5. Compare IRIs
- final iri2 = IRI('https://例子.com/pȧth?q=1');
- print('IRIs equal: ${iri == iri2}'); // Output: IRIs equal: true
-
- final iri3 = IRI('https://example.com/');
- print('IRIs equal: ${iri == iri3}'); // Output: IRIs equal: false
+ // Convert to a standard URI for network operations
+ final uri = iri.toUri();
+ print('URI host: ${uri.host}'); // xn--rsum-bpad.example.org
+ print('URI string: $uri'); // http://xn--rsum-bpad.example.org/r%C3%A9sum%C3%A9
}
final iri = Iri(
+ scheme: 'https',
+ host: 'münchen.test',
+ path: '/city',
+);
+
+print(iri.toUri()); // https://xn--mnchen-3ya.test/city
+An Internationalized Resource Identifier (IRI).
+An IRI is a sequence of characters from the Universal Character Set (Unicode). +It provides a complement to the Uniform Resource Identifier (URI).
+This implementation is a wrapper around the native Uri class, providing +Seamless mapping to URIs as defined in RFC 3987.
+All strings passed to constructors or parsing methods are automatically +normalized to Normalization Form KC (NFKC).
+reference against this IRI.
+
+
+reference against this IRI.
+
+
+Creates a new IRI from its components.
+This mirrors the Uri constructor. All string components are +normalized to NFKC.
+Iri({
+ String? scheme,
+ String? userInfo,
+ String? host,
+ int? port,
+ String? path,
+ Iterable<String>? pathSegments,
+ String? query,
+ Map<String, dynamic>? queryParameters,
+ String? fragment,
+}) : _uri = Uri(
+ scheme: scheme,
+ userInfo: userInfo != null ? unorm.nfkc(userInfo) : null,
+ host: host != null ? unorm.nfkc(host) : null,
+ port: port,
+ path: path != null ? unorm.nfkc(path) : null,
+ pathSegments: pathSegments?.map(unorm.nfkc),
+ query: query != null ? unorm.nfkc(query) : null,
+ queryParameters: queryParameters?.map((k, v) {
+ return MapEntry(unorm.nfkc(k), v is String ? unorm.nfkc(v) : v);
+ }),
+ fragment: fragment != null ? unorm.nfkc(fragment) : null,
+ );Creates a new http IRI from its components.
+Iri.http(
+ String host, [
+ String path = '',
+ Map<String, dynamic>? queryParameters,
+]) : _uri = Uri.http(
+ unorm.nfkc(host),
+ unorm.nfkc(path),
+ queryParameters?.map((k, v) {
+ return MapEntry(unorm.nfkc(k), v is String ? unorm.nfkc(v) : v);
+ }),
+ );Creates a new https IRI from its components.
+Iri.https(
+ String host, [
+ String path = '',
+ Map<String, dynamic>? queryParameters,
+]) : _uri = Uri.https(
+ unorm.nfkc(host),
+ unorm.nfkc(path),
+ queryParameters?.map((k, v) {
+ return MapEntry(unorm.nfkc(k), v is String ? unorm.nfkc(v) : v);
+ }),
+ );Parses a string into an Iri.
+The input string is normalized to NFKC before parsing.
+factory Iri.parse(String input) {
+ final normalized = unorm.nfkc(input);
+ return Iri._(Uri.parse(normalized));
+}The Unicode-aware fragment of this IRI.
+String get fragment => Uri.decodeComponent(_uri.fragment);The hash code for this object.
+A hash code is a single integer which represents the state of the object +that affects operator == comparisons.
+All objects have hash codes. +The default hash code implemented by Object +represents only the identity of the object, +the same way as the default operator == implementation only considers objects +equal if they are identical (see identityHashCode).
+If operator == is overridden to use the object state instead, +the hash code must also be changed to represent that state, +otherwise the object cannot be used in hash based data structures +like the default Set and Map implementations.
+Hash codes must be the same for objects that are equal to each other +according to operator ==. +The hash code of an object should only change if the object changes +in a way that affects equality. +There are no further requirements for the hash codes. +They need not be consistent between executions of the same program +and there are no distribution guarantees.
+Objects that are not equal are allowed to have the same hash code. +It is even technically allowed that all instances have the same hash code, +but if clashes happen too often, +it may reduce the efficiency of hash-based data structures +like HashSet or HashMap.
+If a subclass overrides hashCode, it should override the +operator == operator as well to maintain consistency.
+@override
+int get hashCode => toUri().hashCode;The Unicode-aware host of this IRI.
+If the host was Punycode-encoded (e.g., from a Uri), it is decoded back +to its Unicode representation.
+String get host {
+ final decoded = Uri.decodeComponent(_uri.host);
+ return domainToUnicode(decoded);
+}The equality operator.
+The default behavior for all Objects is to return true if and
+only if this object and other are the same object.
Override this method to specify a different equality relation on +a class. The overriding method must still be an equivalence relation. +That is, it must be:
+Total: It must return a boolean for all arguments. It should never throw.
+Reflexive: For all objects o, o == o must be true.
Symmetric: For all objects o1 and o2, o1 == o2 and o2 == o1 must
+either both be true, or both be false.
Transitive: For all objects o1, o2, and o3, if o1 == o2 and
+o2 == o3 are true, then o1 == o3 must be true.
The method should also be consistent over time, +so whether two objects are equal should only change +if at least one of the objects was modified.
+If a subclass overrides the equality operator, it should override +the hashCode method as well to maintain consistency.
+@override
+bool operator ==(Object other) =>
+ identical(this, other) || (other is Iri && toUri() == other.toUri());The Unicode-aware path of this IRI.
+String get path {
+ final decoded = Uri.decodeComponent(_uri.path);
+ if (scheme == 'mailto') {
+ try {
+ return emailToUnicode(decoded);
+ } on FormatException {
+ return decoded;
+ }
+ }
+ return decoded;
+}The port of this IRI.
+int get port => _uri.port;The Unicode-aware query of this IRI.
+String get query => Uri.decodeComponent(_uri.query);Creates a new IRI by replacing some of the components of this IRI.
+This mirrors the Uri.replace method. All string components are +normalized to NFKC.
+Iri replace({
+ String? scheme,
+ String? userInfo,
+ String? host,
+ int? port,
+ String? path,
+ Iterable<String>? pathSegments,
+ String? query,
+ Map<String, dynamic>? queryParameters,
+ String? fragment,
+}) {
+ return Iri.fromUri(
+ _uri.replace(
+ scheme: scheme,
+ userInfo: userInfo != null ? unorm.nfkc(userInfo) : null,
+ host: host != null ? unorm.nfkc(host) : null,
+ port: port,
+ path: path != null ? unorm.nfkc(path) : null,
+ pathSegments: pathSegments?.map(unorm.nfkc),
+ query: query != null ? unorm.nfkc(query) : null,
+ queryParameters: queryParameters?.map((k, v) {
+ return MapEntry(unorm.nfkc(k), v is String ? unorm.nfkc(v) : v);
+ }),
+ fragment: fragment != null ? unorm.nfkc(fragment) : null,
+ ),
+ );
+}Resolves reference against this IRI.
The reference is normalized to NFKC before being parsed and resolved.
Iri resolve(String reference) {
+ final normalized = unorm.nfkc(reference);
+ return Iri.fromUri(_uri.resolve(normalized));
+}The scheme of this IRI.
+String get scheme => _uri.scheme;Returns the Unicode representation of this IRI.
+@override
+String toString() {
+ final sb = StringBuffer();
+ if (scheme.isNotEmpty) {
+ sb.write(scheme);
+ sb.write(':');
+ }
+ if (_uri.hasAuthority || scheme == 'file') {
+ sb.write('//');
+ if (userInfo.isNotEmpty) {
+ sb.write(userInfo);
+ sb.write('@');
+ }
+ sb.write(host);
+ if (_uri.hasPort) {
+ sb.write(':');
+ sb.write(port);
+ }
+ }
+ sb.write(path);
+ if (_uri.hasQuery) {
+ sb.write('?');
+ sb.write(query);
+ }
+ if (_uri.hasFragment) {
+ sb.write('#');
+ sb.write(fragment);
+ }
+ return sb.toString();
+}Converts this IRI to a standard Uri.
+Any non-ASCII characters in the hostname are converted to Punycode +according to RFC 3492. Other components are percent-encoded using UTF-8.
+Uri toUri() {
+ if (scheme == 'mailto') {
+ final decodedPath = Uri.decodeComponent(_uri.path);
+ try {
+ final punyEmail = emailToAscii(decodedPath, validate: false);
+ return _uri.replace(path: punyEmail);
+ } on FormatException {
+ return _uri;
+ }
+ }
+
+ final decodedHost = Uri.decodeComponent(_uri.host);
+ if (decodedHost.isEmpty) {
+ return _uri;
+ }
+
+ final punyHost = domainToAscii(decodedHost, validate: false);
+ return _uri.replace(host: punyHost);
+}Returns the percent-encoded URI string representation of this IRI.
+String toUriString() => _uri.toString();Parses a string into an Iri, or returns null if it fails.
+The input string is normalized to NFKC before parsing.
+static Iri? tryParse(String input) {
+ final normalized = unorm.nfkc(input);
+ final uri = Uri.tryParse(normalized);
+ return uri == null ? null : Iri._(uri);
+}The Unicode-aware user information of this IRI.
+String get userInfo => Uri.decodeComponent(_uri.userInfo);Provides support for Internationalized Resource Identifiers (IRIs) -based on RFC 3987.
-This library defines the IRI class, which allows parsing, validation, +based on RFC 3987 (https://www.rfc-editor.org/rfc/rfc3987).
+This library defines the Iri class, which allows parsing, validation,
manipulation, and conversion of IRIs. IRIs extend the syntax of Uniform
Resource Identifiers (URIs) to support a wider range of characters from the
-Universal Character Set (Unicode/ISO 10646)cite: 7, 99.
Use the IRI class to work with resource identifiers that may contain +Universal Character Set (Unicode/ISO 10646).
+Use the Iri class to work with resource identifiers that may contain non-ASCII characters, commonly found in international contexts. It handles conversions to and from standard URIs, including Punycode encoding for internationalized domain names (IDNs) and percent-encoding for other @@ -79,7 +76,7 @@
See the IRI class documentation for more details on available methods +
See the Iri class documentation for more details on available methods and properties.