pub fn new(output: Output, config: &'config Config) -> Self {

        Self {

            output,

            nested: Vec::new(),

            config: Cow::Borrowed(config),

        }

    }

    pub fn finish(self) -> Output {

        assert!(self.nested.is_empty());

        self.output

    }

    pub fn begin_named_map(&mut self, name: &str) -> fmt::Result {

        self.prepare_to_write_value()?;

        self.output.write_str(name)?;

        if matches!(self.config.as_ref(), Config::Pretty { .. }) {

            self.output.write_char(' ')?;

        }

        self.output.write_char('{')?;

        self.nested.push(NestedState::Map(MapState::Empty));

        Ok(())

    }

    pub fn begin_named_tuple(&mut self, name: &str) -> fmt::Result {

        self.prepare_to_write_value()?;

        self.nested.push(NestedState::Tuple(SequenceState::Empty));

        self.output.write_str(name)?;

        self.output.write_char('(')

    }

    pub fn begin_map(&mut self) -> fmt::Result {

        self.prepare_to_write_value()?;

        self.nested.push(NestedState::Map(MapState::Empty));

        self.output.write_char('{')

    }

    pub fn begin_list(&mut self) -> fmt::Result {

        self.prepare_to_write_value()?;

        self.nested.push(NestedState::List(SequenceState::Empty));

        self.output.write_char('[')

    }

    pub fn write_primitive<P>(&mut self, p: &P) -> fmt::Result

    where

        P: Primitive + ?Sized,

    {

        self.prepare_to_write_value()?;

        p.render_to(&mut self.output)

    }

    pub fn write_raw_value(&mut self, ident: &str) -> fmt::Result {

        self.prepare_to_write_value()?;

        self.output.write_str(ident)

    }

    fn prepare_to_write_value(&mut self) -> fmt::Result {

        match self.nested.last_mut() {

                NestedState::List(state @ SequenceState::Empty)

                | NestedState::Tuple(state @ SequenceState::Empty),

                *state = SequenceState::NotEmpty;

                self.insert_newline()?;

                self.output.write_char(',')?;

                self.insert_newline()?;

            Some(NestedState::Map(state @ MapState::Empty)) => {

                *state = MapState::AfterKey;

                self.insert_newline()?;

            Some(NestedState::Map(state @ MapState::AfterEntry)) => {

                *state = MapState::AfterKey;

                self.output.write_char(',')?;

                self.insert_newline()?;

            Some(NestedState::Map(state @ MapState::AfterKey)) => {

                *state = MapState::AfterEntry;

                if matches!(self.config.as_ref(), Config::Compact) {

                    self.output.write_char(':')?;

                    self.output.write_str(": ")?;

            None => {}

        Ok(())

    }

    pub fn insert_newline(&mut self) -> fmt::Result {

            indentation,

            newline,

        } = self.config.as_ref()

            self.output.write_str(newline)?;

            for _ in 0..self.nested.len() {

                self.output.write_str(indentation)?;

        }

        Ok(())

    }

    pub fn finish_nested(&mut self) -> fmt::Result {

        match self.nested.pop().expect("not in a nested state") {

            NestedState::Tuple(state) => {

                if matches!(state, SequenceState::NotEmpty) {

                    self.insert_newline()?;

                self.output.write_char(')')

            NestedState::List(state) => {

                if matches!(state, SequenceState::NotEmpty) {

                    self.insert_newline()?;

                self.output.write_char(']')

            NestedState::Map(state @ (MapState::AfterEntry | MapState::Empty)) => {

                if matches!(state, MapState::AfterEntry) {

                    self.insert_newline()?;

                self.output.write_char('}')

    }

    pub fn write_value(&mut self, value: &Value<'_>) -> fmt::Result {

        match value {

            Value::Identifier(value) | Value::String(value) => self.write_primitive(value.as_ref()),

            Value::Named(value) => {

                match &value.contents {

                    StructContents::Tuple(seq) => {

                        self.begin_named_tuple(&value.name)?;

                        for value in &seq.0 {

                            self.write_value(value)?;

                self.finish_nested()

    }

            fn render_to<W: Write>(&self, buffer: &mut W) -> fmt::Result {

                write!(buffer, "{self}")

            }

    fn render_to<W: Write>(&self, buffer: &mut W) -> fmt::Result {

        buffer.write_char('"')?;

        for ch in self.chars() {

            escape_string_char(ch, buffer)?;

        buffer.write_char('"')

    }

    fn render_to<W: Write>(&self, buffer: &mut W) -> fmt::Result {

        buffer.write_str(if *self { "true" } else { "false" })

    }

    fn render_to<W: Write>(&self, buffer: &mut W) -> fmt::Result {

        buffer.write_str("b\"")?;

        for byte in self {

            match DEFAULT_STRING_ESCAPE_HANDLING.get(usize::from(*byte)) {

                Some(Some(escaped)) => {

                    buffer.write_str(escaped)?;

                    buffer.write_char(char::from(*byte))?;

                    write!(buffer, "\\x{byte:02x}")?;

        buffer.write_char('"')

    }

fn escape_string_char<W: Write>(ch: char, buffer: &mut W) -> fmt::Result {

    if let Ok(cp) = usize::try_from(u32::from(ch)) {

        if let Some(Some(escaped)) = DEFAULT_STRING_ESCAPE_HANDLING.get(cp) {

            return buffer.write_str(escaped);

        }

    let mut utf8_bytes = [0; 8];

    buffer.write_str(ch.encode_utf8(&mut utf8_bytes))

}

    fn render_to<W: Write>(&self, buffer: &mut W) -> fmt::Result {

        buffer.write_char('\'')?;

        escape_string_char(*self, buffer)?;

        buffer.write_char('\'')

    }

fn string_rendering() {

    let mut to_encode = String::new();

    for ch in 0_u8..128 {

        to_encode.push(ch as char);

    }

    to_encode.write_char('\u{1_F980}').unwrap();

    let mut rendered = String::new();

    to_encode.render_to(&mut rendered).unwrap();

    assert_eq!(

        rendered,

        "\"\\0\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\t\\n\\x0b\\x0c\\r\\x0e\\x0f\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a\\x1b\\x1c\\x1d\\x1e\\x1f !\\\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\\x7f🦀\""

    );

        kind: TokenKind::String(parsed),

    })) = Tokenizer::full(&rendered).next()

    assert_eq!(parsed, to_encode);

}

fn byte_rendering() {

    let mut to_encode = Vec::new();

    for ch in 0_u8..255 {

        to_encode.push(ch);

    }

    let mut rendered = String::new();

    to_encode.render_to(&mut rendered).unwrap();

    assert_eq!(

        rendered,

        "b\"\\0\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\t\\n\\x0b\\x0c\\r\\x0e\\x0f\\x10\\x11\\x12\\x13\\x14\\x15\\x16\\x17\\x18\\x19\\x1a\\x1b\\x1c\\x1d\\x1e\\x1f !\\\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\\x7f\\x80\\x81\\x82\\x83\\x84\\x85\\x86\\x87\\x88\\x89\\x8a\\x8b\\x8c\\x8d\\x8e\\x8f\\x90\\x91\\x92\\x93\\x94\\x95\\x96\\x97\\x98\\x99\\x9a\\x9b\\x9c\\x9d\\x9e\\x9f\\xa0\\xa1\\xa2\\xa3\\xa4\\xa5\\xa6\\xa7\\xa8\\xa9\\xaa\\xab\\xac\\xad\\xae\\xaf\\xb0\\xb1\\xb2\\xb3\\xb4\\xb5\\xb6\\xb7\\xb8\\xb9\\xba\\xbb\\xbc\\xbd\\xbe\\xbf\\xc0\\xc1\\xc2\\xc3\\xc4\\xc5\\xc6\\xc7\\xc8\\xc9\\xca\\xcb\\xcc\\xcd\\xce\\xcf\\xd0\\xd1\\xd2\\xd3\\xd4\\xd5\\xd6\\xd7\\xd8\\xd9\\xda\\xdb\\xdc\\xdd\\xde\\xdf\\xe0\\xe1\\xe2\\xe3\\xe4\\xe5\\xe6\\xe7\\xe8\\xe9\\xea\\xeb\\xec\\xed\\xee\\xef\\xf0\\xf1\\xf2\\xf3\\xf4\\xf5\\xf6\\xf7\\xf8\\xf9\\xfa\\xfb\\xfc\\xfd\\xfe\""

    );

        kind: TokenKind::Bytes(parsed),

    })) = Tokenizer::full(&rendered).next()

    assert_eq!(parsed, to_encode);

}