object

# `url(Representation)`

- `Representation` - URL and is components representation. Valid values are `atom`, `codes`, and `chars`.

URL validating, parsing, and normalizing predicates following RFC3986 nomenclature.

Availability:
`logtalk_load(url(loader))`
Author: Paulo Moura
Version: 2:0:0
Date: 2026-05-22
Compilation flags:
`static, context_switching_calls`
Uses:
list
Remarks:
(none)
Inherited public predicates:
(none)

## Public predicates

### `valid/1`

True iff the argument is a valid URL, including optional query and fragment components.

Compilation flags:
`static`
Template:
`valid(URL)`
Mode and number of proofs:
`valid(++text)` - `zero_or_one`

### `parse/2`

Parses a URL into a list of its components: `[scheme(Scheme), authority(Authority), path(Path), query(Query), fragment(Fragment)]`. Fails if the URL is invalid and cannot be parsed.

Compilation flags:
`static`
Template:
`parse(URL,Components)`
Mode and number of proofs:
`parse(++text,-list(compound))` - `zero_or_one`

### `generate/2`

Generates a normalized URL or RFC3986 relative reference from a list of components. Component lists headed by `scheme/1` generate absolute URLs; lists without `scheme/1` generate relative references.

Compilation flags:
`static`
Template:
`generate(Components,URL)`
Mode and number of proofs:
`generate(++list(compound),-text)` - `zero_or_one`

### `parse/3`

Parses a URL or RFC3986 relative reference into a list of its components and classifies it as one of `url`, `network_path`, `absolute_path`, `relative_path`, `query`, or `fragment`.

Compilation flags:
`static`
Template:
`parse(Reference,Components,Kind)`
Mode and number of proofs:
`parse(++text,-list(compound),-atom)` - `zero_or_one`

### `reference_kind/2`

Classifies a valid reference as one of `url`, `network_path`, `absolute_path`, `relative_path`, `query`, or `fragment`.

Compilation flags:
`static`
Template:
`reference_kind(Reference,Kind)`
Mode and number of proofs:
`reference_kind(++text,-atom)` - `zero_or_one`

### `equivalent/2`

True iff both arguments normalize to the same textual representation under the library normalization rules.

Compilation flags:
`static`
Template:
`equivalent(Reference1,Reference2)`
Mode and number of proofs:
`equivalent(++text,++text)` - `zero_or_one`

### `relativize/3`

Relativizes a target absolute hierarchical URL against a base absolute hierarchical URL with the same scheme and authority, returning a non-empty relative reference accepted by the library. Fails when no such non-empty relative reference can be generated.

Compilation flags:
`static`
Template:
`relativize(Base,Target,Relative)`
Mode and number of proofs:
`relativize(++text,++text,-text)` - `zero_or_one`

### `resolve/3`

Resolves a reference against a base absolute hierarchical URL and returns a normalized absolute URL. The first argument must be an absolute hierarchical URL suitable for use as a base. The second argument may be either a relative reference or an absolute URL; when it is already absolute, the result is that absolute URL normalized and returned unchanged apart from normalization.

Compilation flags:
`static`
Template:
`resolve(Base,Reference,Resolved)`
Mode and number of proofs:
`resolve(++text,++text,-text)` - `zero_or_one`

### `normalize/2`

Normalizes a URL or RFC3986 relative reference by standardizing its components. Normalization includes converting the scheme to lowercase when present, normalizing the authority, percent-encoding characters that require escaping, and simplifying path dot segments while preserving absolute and relative reference forms.

Compilation flags:
`static`
Template:
`normalize(Reference,NormalizedReference)`
Mode and number of proofs:
`normalize(++text,-text)` - `one`

### `file_path_components/2`

Converts a file-system path into file URL components represented as `[authority(Authority), path(Path)]`. Windows drive-letter and UNC paths are normalized to RFC3986-compatible file URL components.

Compilation flags:
`static`
Template:
`file_path_components(FilePath,Components)`
Mode and number of proofs:
`file_path_components(++text,-list(compound))` - `one`

## Protected predicates

(no local declarations; see entity ancestors if any)

## Private predicates

### `downcase_text/2`

Converts text to lowercase (ASCII only). Only uppercase letters A-Z are converted to lowercase.

Compilation flags:
`static`
Template:
`downcase_text(Text,LowerText)`
Mode and number of proofs:
`downcase_text(+text,-text)` - `one`

## Operators

(none)