| use std::{ |
| borrow::Cow, |
| fmt::{Display, Write}, |
| }; |
|
|
| use once_cell::sync::Lazy; |
| use regex::{Captures, Regex, Replacer}; |
|
|
| pub fn mangle(content: &str) -> String { |
| let mut r = "__TURBOPACK__".to_string(); |
| let mut hex_mode = false; |
| for c in content.chars() { |
| if matches!(c, '0'..='9' | 'A'..='Z' | 'a'..='z' | ' ') { |
| if hex_mode { |
| r.push('$'); |
| hex_mode = false; |
| } |
| if c == ' ' { |
| r += "__"; |
| } else { |
| r.push(c); |
| } |
| } else if c == '_' && (!r.ends_with('_') || hex_mode) { |
| if hex_mode { |
| r.push('$'); |
| hex_mode = false; |
| } |
| r += "_"; |
| } else if c == '$' && !hex_mode { |
| r += "$$"; |
| } else if matches!(c, '\0'..='\u{ff}') { |
| if !hex_mode { |
| r.push('$'); |
| hex_mode = true; |
| } |
| write!(r, "{0:2x}", c as u8).unwrap(); |
| } else { |
| if !hex_mode { |
| r.push('$'); |
| } |
| write!(r, "_{:x}$", c as u32).unwrap(); |
| hex_mode = false; |
| } |
| } |
| if hex_mode { |
| r.push('$'); |
| } |
| r += "__"; |
| r |
| } |
|
|
| |
| pub fn unmangle(identifier: &str) -> String { |
| static DECODE_REGEX: Lazy<Regex> = |
| Lazy::new(|| Regex::new(r"^__TURBOPACK__([a-zA-Z0-9_$]+)__$").unwrap()); |
|
|
| let Some(captures) = DECODE_REGEX.captures(identifier) else { |
| return identifier.to_string(); |
| }; |
|
|
| let content = captures.get(1).unwrap().as_str(); |
|
|
| enum Mode { |
| Text, |
| Underscore, |
| Hex, |
| LongHex, |
| } |
| let mut mode = Mode::Text; |
| let mut output = String::new(); |
| let mut buffer = String::with_capacity(2); |
| for char in content.chars() { |
| match mode { |
| Mode::Text => match char { |
| '_' => mode = Mode::Underscore, |
| '$' => mode = Mode::Hex, |
| c => output.push(c), |
| }, |
| Mode::Underscore => match char { |
| '_' => { |
| output.push(' '); |
| mode = Mode::Text; |
| } |
| '$' => { |
| output.push('_'); |
| mode = Mode::Hex; |
| } |
| c => { |
| output.push('_'); |
| output.push(c); |
| mode = Mode::Text; |
| } |
| }, |
| Mode::Hex => { |
| if buffer.len() == 2 { |
| if let Ok(byte) = u8::from_str_radix(&buffer, 16) { |
| output.push(byte as char); |
| } |
| buffer.clear(); |
| } |
| match char { |
| '_' => { |
| debug_assert!(buffer.is_empty()); |
| mode = Mode::LongHex; |
| } |
| '$' => { |
| debug_assert!(buffer.is_empty()); |
| mode = Mode::Text; |
| } |
| c => { |
| buffer.push(c); |
| } |
| } |
| } |
| Mode::LongHex => { |
| debug_assert!(char != '_'); |
| match char { |
| '$' => { |
| if let Ok(code) = u32::from_str_radix(&buffer, 16) { |
| output.push(std::char::from_u32(code).unwrap()); |
| } |
| buffer.clear(); |
| mode = Mode::Text; |
| } |
| c => { |
| buffer.push(c); |
| } |
| } |
| } |
| } |
| } |
| debug_assert!(matches!(mode, Mode::Text)); |
| output |
| } |
|
|
| |
| pub fn unmangle_identifiers<T: Display>(text: &str, magic: impl Fn(String) -> T) -> Cow<'_, str> { |
| static IDENTIFIER_REGEX: Lazy<Regex> = |
| Lazy::new(|| Regex::new(r"__TURBOPACK__[a-zA-Z0-9_$]+__").unwrap()); |
|
|
| struct Rep<T: Fn(String) -> O, O: Display>(T); |
|
|
| impl<T: Fn(String) -> O, O: Display> Replacer for Rep<T, O> { |
| fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut String) { |
| write!(dst, "{}", self.0(unmangle(caps.get(0).unwrap().as_str()))).unwrap(); |
| } |
| } |
|
|
| IDENTIFIER_REGEX.replace_all(text, Rep(magic)) |
| } |
|
|
| #[cfg(test)] |
| mod tests { |
| use super::*; |
|
|
| #[test] |
| fn test_encode() { |
| assert_eq!(mangle("Hello World"), "__TURBOPACK__Hello__World__"); |
| assert_eq!(mangle("Hello_World"), "__TURBOPACK__Hello_World__"); |
| assert_eq!(mangle("Hello__World"), "__TURBOPACK__Hello_$5f$World__"); |
| assert_eq!(mangle("Hello___World"), "__TURBOPACK__Hello_$5f$_World__"); |
| assert_eq!(mangle("Hello/World"), "__TURBOPACK__Hello$2f$World__"); |
| assert_eq!(mangle("Hello///World"), "__TURBOPACK__Hello$2f2f2f$World__"); |
| assert_eq!(mangle("Hello/_World"), "__TURBOPACK__Hello$2f$_World__"); |
| assert_eq!(mangle("Hello_/_World"), "__TURBOPACK__Hello_$2f$_World__"); |
| assert_eq!(mangle("Hello😀World"), "__TURBOPACK__Hello$_1f600$World__"); |
| assert_eq!( |
| mangle("Hello/😀/World"), |
| "__TURBOPACK__Hello$2f_1f600$$2f$World__" |
| ); |
| assert_eq!( |
| mangle("Hello😀😀World"), |
| "__TURBOPACK__Hello$_1f600$$_1f600$World__" |
| ); |
| } |
|
|
| #[test] |
| fn test_decode() { |
| assert_eq!(unmangle("__TURBOPACK__Hello__World__"), "Hello World"); |
| assert_eq!(unmangle("__TURBOPACK__Hello_World__"), "Hello_World"); |
| assert_eq!(unmangle("__TURBOPACK__Hello_$5f$World__"), "Hello__World"); |
| assert_eq!(unmangle("__TURBOPACK__Hello_$5f$_World__"), "Hello___World"); |
| assert_eq!(unmangle("__TURBOPACK__Hello$2f$World__"), "Hello/World"); |
| assert_eq!( |
| unmangle("__TURBOPACK__Hello$2f2f2f$World__"), |
| "Hello///World" |
| ); |
| assert_eq!(unmangle("__TURBOPACK__Hello$2f$_World__"), "Hello/_World"); |
| assert_eq!(unmangle("__TURBOPACK__Hello_$2f$_World__"), "Hello_/_World"); |
| assert_eq!( |
| unmangle("__TURBOPACK__Hello$_1f600$World__"), |
| "Hello😀World" |
| ); |
| assert_eq!( |
| unmangle("__TURBOPACK__Hello$2f_1f600$$2f$World__"), |
| "Hello/😀/World" |
| ); |
| assert_eq!( |
| unmangle("__TURBOPACK__Hello$_1f600$$_1f600$World__"), |
| "Hello😀😀World" |
| ); |
| } |
|
|
| #[test] |
| fn test_unmangle_identifiers() { |
| assert_eq!( |
| unmangle_identifiers( |
| "Hello __TURBOPACK__Hello__World__ __TURBOPACK__Hello_World__", |
| |s| format!("{{{s}}}") |
| ), |
| "Hello {Hello World} {Hello_World}" |
| ); |
| } |
| } |
|
|
