let bitset_value = NEEDS_ESCAPING_BITSET[(c / 64) as usize] & (1 << (c % 64));

if bitset_value == 0 {

None

} else {

Some(match c {

x if x < 0x20 => ESCAPE_CHARS[c as usize],

b'\\' => "\\\\",

b'\"' => "\\\"",

0x7F => "\\u007f",

_ => unreachable!(),

})

}

w.write_all(b"\"")?;

let mut write_start_idx = 0;

let bytes = s.as_bytes();

if ascii_only {

for (idx, c) in s.char_indices() {

if c.is_ascii() {

if let Some(escaped) = json_escaped_char(c as u8) {

w.write_all(&bytes[write_start_idx..idx])?;

w.write_all(escaped.as_bytes())?;

write_start_idx = idx + 1;

}

} else {

w.write_all(&bytes[write_start_idx..idx])?;

write_start_idx = idx + c.len_utf8();

// codepoints outside the BMP get 2 '\uxxxx' sequences to represent them

for point in c.encode_utf16(&mut [0; 2]) {

write!(w, "\\u{:04x}", point)?;

}

}

}

} else {

for (idx, c) in s.bytes().enumerate() {

if let Some(escaped) = json_escaped_char(c) {

w.write_all(&bytes[write_start_idx..idx])?;

w.write_all(escaped.as_bytes())?;

write_start_idx = idx + 1;

}

}

}

w.write_all(&bytes[write_start_idx..])?;

w.write_all(b"\"")

fn new(msg: impl Into<String>, pos: usize) -> Self {

Self {

msg: msg.into(),

pos,

}

}

fn len(&self) -> usize {

match self {

StrOrChar::Str(s) => s.len(),

StrOrChar::Char(c) => c.len_utf8(),

}

}

s: &'a str,

end: usize,

strict: bool,

) -> Result<(String, usize), DecodeError> {

let mut chunks: Vec<StrOrChar<'a>> = Vec::new();

let mut output_len = 0usize;

let mut push_chunk = |chunk: StrOrChar<'a>| {

output_len += chunk.len();

chunks.push(chunk);

};

let unterminated_err = || DecodeError::new("Unterminated string starting at", end - 1);

let mut chunk_start = end;

let mut chars = s.char_indices().enumerate().skip(end).peekable();

while let Some((char_i, (i, c))) = chars.next() {

match c {

'"' => {

push_chunk(StrOrChar::Str(&s[chunk_start..i]));

let mut out = String::with_capacity(output_len);

for x in chunks {

match x {

StrOrChar::Str(s) => out.push_str(s),

StrOrChar::Char(c) => out.push(c),

}

}

return Ok((out, char_i + 1));

}

'\\' => {

push_chunk(StrOrChar::Str(&s[chunk_start..i]));

let (_, (_, c)) = chars.next().ok_or_else(unterminated_err)?;

let esc = match c {

'"' => "\"",

'\\' => "\\",

'/' => "/",

'b' => "\x08",

'f' => "\x0c",

'n' => "\n",

'r' => "\r",

't' => "\t",

'u' => {

let surrogate_err = || DecodeError::new("unpaired surrogate", char_i);

let mut uni = decode_unicode(&mut chars, char_i)?;

chunk_start = char_i + 6;

if (0xd800..=0xdbff).contains(&uni) {

// uni is a surrogate -- try to find its pair

if let Some(&(pos2, (_, '\\'))) = chars.peek() {

// ok, the next char starts an escape

chars.next();

if let Some((_, (_, 'u'))) = chars.peek() {

// ok, it's a unicode escape

chars.next();

let uni2 = decode_unicode(&mut chars, pos2)?;

chunk_start = pos2 + 6;

if (0xdc00..=0xdfff).contains(&uni2) {

// ok, we found what we were looking for -- \uXXXX\uXXXX, both surrogates

uni = 0x10000 + (((uni - 0xd800) << 10) | (uni2 - 0xdc00));

} else {

// if we don't find a matching surrogate, error -- until str

// isn't utf8 internally, we can't parse surrogates

return Err(surrogate_err());

}

} else {

return Err(surrogate_err());

}

}

}

push_chunk(StrOrChar::Char(

std::char::from_u32(uni).ok_or_else(surrogate_err)?,

));

continue;

}

_ => {

return Err(DecodeError::new(

format!("Invalid \\escape: {:?}", c),

char_i,

))

}

};

chunk_start = i + 2;

push_chunk(StrOrChar::Str(esc));

}

'\x00'..='\x1f' if strict => {

return Err(DecodeError::new(

format!("Invalid control character {:?} at", c),

char_i,

));

}

_ => {}

}

}

Err(unterminated_err())

I: Iterator<Item = (usize, (usize, char))>,

let err = || DecodeError::new("Invalid \\uXXXX escape", pos);

let mut uni = 0;

for x in (0..4).rev() {

let (_, (_, c)) = it.next().ok_or_else(err)?;

let d = c.to_digit(16).ok_or_else(err)?;

uni += d * 16u32.pow(x);

}

Ok(uni)