1const 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
51pub(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
89pub(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
142pub 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
151pub fn decode_to_string(input: &str) -> Option<String> {
153 decode(input).map(|chars| chars.into_iter().collect())
154}