Skip to main content

parsec_url/
punycode.rs

1// SPDX-License-Identifier: Apache-2.0
2// Copyright 2026 James Conway
3
4//! RFC 3492 Punycode, one label at a time and without the `xn--` prefix.
5//!
6//! ```
7//! use parsec_url::punycode;
8//!
9//! assert_eq!(punycode::encode_str("bücher").unwrap(), "bcher-kva");
10//! assert_eq!(punycode::decode_to_string("bcher-kva").unwrap(), "bücher");
11//! ```
12
13const BASE: u32 = 36;
14const T_MIN: u32 = 1;
15const T_MAX: u32 = 26;
16const SKEW: u32 = 38;
17const DAMP: u32 = 700;
18const INITIAL_BIAS: u32 = 72;
19const INITIAL_N: u32 = 128;
20
21fn adapt(mut delta: u32, points: u32, first: bool) -> u32 {
22    delta /= if first { DAMP } else { 2 };
23    delta += delta / points;
24    let mut k = 0;
25    while delta > ((BASE - T_MIN) * T_MAX) / 2 {
26        delta /= BASE - T_MIN;
27        k += BASE;
28    }
29    k + (BASE - T_MIN + 1) * delta / (delta + SKEW)
30}
31
32fn threshold(k: u32, bias: u32) -> u32 {
33    if k <= bias {
34        T_MIN
35    } else if k >= bias + T_MAX {
36        T_MAX
37    } else {
38        k - bias
39    }
40}
41
42fn digit_value(b: u8) -> Option<u32> {
43    match b {
44        b'a'..=b'z' => Some((b - b'a') as u32),
45        b'A'..=b'Z' => Some((b - b'A') as u32),
46        b'0'..=b'9' => Some((b - b'0') as u32 + 26),
47        _ => None,
48    }
49}
50
51/// Decodes a Punycode label into code points, or `None` if it isn't
52/// valid Punycode or decodes to something that isn't a scalar value.
53pub(crate) fn decode(input: &str) -> Option<Vec<char>> {
54    let bytes = input.as_bytes();
55    let (basic, extended) = match bytes.iter().rposition(|&b| b == b'-') {
56        Some(at) => (&bytes[..at], &bytes[at + 1..]),
57        None => (&bytes[..0], bytes),
58    };
59    if !basic.is_ascii() {
60        return None;
61    }
62    let mut out: Vec<char> = basic.iter().map(|&b| b as char).collect();
63    let (mut n, mut i, mut bias) = (INITIAL_N, 0u32, INITIAL_BIAS);
64    let mut digits = extended.iter();
65    while digits.len() > 0 {
66        let old_i = i;
67        let mut w = 1u32;
68        let mut k = BASE;
69        loop {
70            let digit = digit_value(*digits.next()?)?;
71            i = i.checked_add(digit.checked_mul(w)?)?;
72            let t = threshold(k, bias);
73            if digit < t {
74                break;
75            }
76            w = w.checked_mul(BASE - t)?;
77            k += BASE;
78        }
79        let len = out.len() as u32 + 1;
80        bias = adapt(i - old_i, len, old_i == 0);
81        n = n.checked_add(i / len)?;
82        i %= len;
83        out.insert(i as usize, char::from_u32(n)?);
84        i += 1;
85    }
86    Some(out)
87}
88
89/// Encodes code points as Punycode, or `None` on overflow.
90pub(crate) fn encode(input: &[char], out: &mut String) -> Option<()> {
91    let start = out.len();
92    out.extend(input.iter().filter(|c| c.is_ascii()));
93    let basic = (out.len() - start) as u32;
94    if basic > 0 {
95        out.push('-');
96    }
97    let (mut n, mut delta, mut bias) = (INITIAL_N, 0u32, INITIAL_BIAS);
98    let mut handled = basic;
99    let total = input.len() as u32;
100    while handled < total {
101        let m = input.iter().map(|&c| c as u32).filter(|&c| c >= n).min()?;
102        delta = delta.checked_add((m - n).checked_mul(handled + 1)?)?;
103        n = m;
104        for &c in input {
105            let c = c as u32;
106            if c < n {
107                delta = delta.checked_add(1)?;
108            }
109            if c == n {
110                let mut q = delta;
111                let mut k = BASE;
112                loop {
113                    let t = threshold(k, bias);
114                    if q < t {
115                        break;
116                    }
117                    let d = t + (q - t) % (BASE - t);
118                    out.push(digit(d));
119                    q = (q - t) / (BASE - t);
120                    k += BASE;
121                }
122                out.push(digit(q));
123                bias = adapt(delta, handled + 1, handled == basic);
124                delta = 0;
125                handled += 1;
126            }
127        }
128        delta = delta.checked_add(1)?;
129        n = n.checked_add(1)?;
130    }
131    Some(())
132}
133
134fn digit(d: u32) -> char {
135    (if d < 26 {
136        b'a' + d as u8
137    } else {
138        b'0' + (d - 26) as u8
139    }) as char
140}
141
142/// Encodes a label as Punycode: `"bücher"` becomes `"bcher-kva"`. `None`
143/// means the arithmetic overflowed, which takes a very long label.
144pub fn encode_str(input: &str) -> Option<String> {
145    let chars: Vec<char> = input.chars().collect();
146    let mut out = String::with_capacity(input.len());
147    encode(&chars, &mut out)?;
148    Some(out)
149}
150
151/// Decodes a Punycode label: `"bcher-kva"` becomes `"bücher"`.
152pub fn decode_to_string(input: &str) -> Option<String> {
153    decode(input).map(|chars| chars.into_iter().collect())
154}