text:
from __future__ import absolute_import
from __future__ import print_function

# Emitter expects events obeying the following grammar:
# stream ::= STREAM-START document* STREAM-END
# document ::= DOCUMENT-START node DOCUMENT-END
# node ::= SCALAR | sequence | mapping
# sequence ::= SEQUENCE-START node* SEQUENCE-END
# mapping ::= MAPPING-START (node node)* MAPPING-END

import sys
from .error import YAMLError, YAMLStreamError
from .events import *  # NOQA

# fmt: off
from .compat import utf8, text_type, PY2, nprint, dbg, DBG_EVENT, \
    check_anchorname_char
# fmt: on

if False:  # MYPY
    from typing import Any, Dict, List, Union, Text, Tuple, Optional  # NOQA
    from .compat import StreamType  # NOQA

__all__ = ["Emitter", "EmitterError"]

class EmitterError(YAMLError):
    pass

class ScalarAnalysis(object):
    def __init__(
        self,
        scalar,
        empty,
        multiline,
        allow_flow_plain,
        allow_block_plain,
        allow_single_quoted,
        allow_double_quoted,
        allow_block,
    ):
        # type: (Any, Any, Any, bool, bool, bool, bool, bool) -> None
        self.scalar = scalar
        self.empty = empty
        self.multiline = multiline
        self.allow_flow_plain = allow_flow_plain
        self.allow_block_plain = allow_block_plain
        self.allow_single_quoted = allow_single_quoted
        self.allow_double_quoted = allow_double_quoted
        self.allow_block = allow_block

class Indents(object):
    # replacement for the list based stack of None/int
    def __init__(self):
        # type: () -> None
        self.values = []  # type: List[Tuple[int, bool]]

    def append(self, val, seq):
        # type: (Any, Any) -> None
        self.values.append((val, seq))

    def pop(self):
        # type: () -> Any
        return self.values.pop()[0]

    def last_seq(self):
        # type: () -> bool
        # return the seq(uence) value for the element added before the last one
        # in increase_indent()
        try:
            return self.values[-2][1]
        except IndexError:
            return False

    def seq_flow_align(self, seq_indent, column):
        # type: (int, int) -> int
        # extra spaces because of dash
        if len(self.values) < 2 or not self.values[-1][1]:
            return 0
        # -1 for the dash
        base = self.values[-1][0] if self.values[-1][0] is not None else 0
        return base + seq_indent - column - 1

    def __len__(self):
        # type: () -> int
        return len(self.values)

class Emitter(object):
    # fmt: off
    DEFAULT_TAG_PREFIXES = {
        u'!': u'!',
        u'tag:yaml.org,2002:': u'!!',
    }
    # fmt: on

    MAX_SIMPLE_KEY_LENGTH = 128

    def __init__(
        self,
        stream,
        canonical=None,
        indent=None,
        width=None,
        allow_unicode=None,
        line_break=None,
        block_seq_indent=None,
        top_level_colon_align=None,
        prefix_colon=None,
        brace_single_entry_mapping_in_flow_sequence=None,
        dumper=None,
    ):
        # type: (StreamType, Any, Optional[int], Optional[int], Optional[bool], Any, Optional[int], Optional[bool], Any, Optional[bool], Any) -> None  # NOQA
        self.dumper = dumper
        if self.dumper is not None and getattr(self.dumper, "_emitter", None) is None:
            self.dumper._emitter = self
        self.stream = stream

        # Encoding can be overriden by STREAM-START.
        self.encoding = None  # type: Optional[Text]
        self.allow_space_break = None

        # Emitter is a state machine with a stack of states to handle nested
        # structures.
        self.states = []  # type: List[Any]
        self.state = self.expect_stream_start  # type: Any

        # Current event and the event queue.
        self.events = []  # type: List[Any]
        self.event = None  # type: Any

        # The current indentation level and the stack of previous indents.
        self.indents = Indents()
        self.indent = None  # type: Optional[int]

        # flow_context is an expanding/shrinking list consisting of '{' and '['
        # for each unclosed flow context. If empty list that means block context
        self.flow_context = []  # type: List[Text]

        # Contexts.
        self.root_context = False
        self.sequence_context = False
        self.mapping_context = False
        self.simple_key_context = False

        # Characteristics of the last emitted character:
        #  - current position.
        #  - is it a whitespace?
        #  - is it an indention character
        #    (indentation space, '-', '?', or ':')?
        self.line = 0
        self.column = 0
        self.whitespace = True
        self.indention = True
        self.compact_seq_seq = True  # dash after dash
        self.compact_seq_map = True  # key after dash
        # self.compact_ms = False   # dash after key, only when excplicit key with ?
        self.no_newline = None  # type: Optional[bool]  # set if directly after `- `

        # Whether the document requires an explicit document end indicator
        self.open_ended = False

        # colon handling
        self.colon = u":"
        self.prefixed_colon = (
            self.colon if prefix_colon is None else prefix_colon + self.colon
        )
        # single entry mappings in flow sequence
        self.brace_single_entry_mapping_in_flow_sequence = (
            brace_single_entry_mapping_in_flow_sequence
        )  # NOQA

        # Formatting details.
        self.canonical = canonical
        self.allow_unicode = allow_unicode
        # set to False to get "\Uxxxxxxxx" for non-basic unicode like emojis
        self.unicode_supplementary = sys.maxunicode > 0xFFFF
        self.sequence_dash_offset = block_seq_indent if block_seq_indent else 0
        self.top_level_colon_align = top_level_colon_align
        self.best_sequence_indent = 2
        self.requested_indent = indent  # specific for literal zero indent
        if indent and 1 < indent < 10:
            self.best_sequence_indent = indent
        self.best_map_indent = self.best_sequence_indent
        # if self.best_sequence_indent < self.sequence_dash_offset + 1:
        #     self.best_sequence_indent = self.sequence_dash_offset + 1
        self.best_width = 80
        if width and width > self.best_sequence_indent * 2:
            self.best_width = width
        self.best_line_break = u"\n"  # type: Any
        if line_break in [u"\r", u"\n", u"\r\n"]:
            self.best_line_break = line_break

        # Tag prefixes.
        self.tag_prefixes = None  # type: Any

        # Prepared anchor and tag.
        self.prepared_anchor = None  # type: Any
        self.prepared_tag = None  # type: Any

        # Scalar analysis and style.
        self.analysis = None  # type: Any
        self.style = None  # type: Any

        self.scalar_after_indicator = True  # write a scalar on the same line as `---`

    @property
    def stream(self):
        # type: () -> Any
        try:
            return self._stream
        except AttributeError:
            raise YAMLStreamError("output stream needs to specified")

    @stream.setter
    def stream(self, val):
        # type: (Any) -> None
        if val is None:
            return
        if not hasattr(val, "write"):
            raise YAMLStreamError("stream argument needs to have a write() method")
        self._stream = val

    @property
    def serializer(self):
        # type: () -> Any
        try:
            if hasattr(self.dumper, "typ"):
                return self.dumper.serializer
            return self.dumper._serializer
        except AttributeError:
            return self  # cyaml

    @property
    def flow_level(self):
        # type: () -> int
        return len(self.flow_context)

    def dispose(self):
        # type: () -> None
        # Reset the state attributes (to clear self-references)
        self.states = []
        self.state = None

    def emit(self, event):
        # type: (Any) -> None
        if dbg(DBG_EVENT):
            nprint(event)
        self.events.append(event)
        while not self.need_more_events():
            self.event = self.events.pop(0)
            self.state()
            self.event = None

    # In some cases, we wait for a few next events before emitting.

    def need_more_events(self):
        # type: () -> bool
        if not self.events:
            return True
        event = self.events[0]
        if isinstance(event, DocumentStartEvent):
            return self.need_events(1)
        elif isinstance(event, SequenceStartEvent):
            return self.need_events(2)
        elif isinstance(event, MappingStartEvent):
            return self.need_events(3)
        else:
            return False

    def need_events(self, count):
        # type: (int) -> bool
        level = 0
        for event in self.events[1:]:
            if isinstance(event, (DocumentStartEvent, CollectionStartEvent)):
                level += 1
            elif isinstance(event, (DocumentEndEvent, CollectionEndEvent)):
                level -= 1
            elif isinstance(event, StreamEndEvent):
                level = -1
            if level < 0:
                return False
        return len(self.events) < count + 1

    def increase_indent(self, flow=False, sequence=None, indentless=False):
        # type: (bool, Optional[bool], bool) -> None
        self.indents.append(self.indent, sequence)
        if self.indent is None:  # top level
            if flow:
                # self.indent = self.best_sequence_indent if self.indents.last_seq() else \
                #              self.best_map_indent
                # self.indent = self.best_sequence_indent
                self.indent = self.requested_indent
            else:
                self.indent = 0
        elif not indentless:
            self.indent += (
                self.best_sequence_indent
                if self.indents.last_seq()
                else self.best_map_indent
            )
            # if self.indents.last_seq():
            #     if self.indent == 0: # top level block sequence
            #         self.indent = self.best_sequence_indent - self.sequence_dash_offset
            #     else:
            #         self.indent += self.best_sequence_indent
            # else:
            #     self.indent += self.best_map_indent

    # States.

    # Stream handlers.

    def expect_stream_start(self):
        # type: () -> None
        if isinstance(self.event, StreamStartEvent):
            if PY2:
                if self.event.encoding and not getattr(self.stream, "encoding", None):
                    self.encoding = self.event.encoding
            else:
                if self.event.encoding and not hasattr(self.stream, "encoding"):
                    self.encoding = self.event.encoding
            self.write_stream_start()
            self.state = self.expect_first_document_start
        else:
            raise EmitterError("expected StreamStartEvent, but got %s" % (self.event,))

    def expect_nothing(self):
        # type: () -> None
        raise EmitterError("expected nothing, but got %s" % (self.event,))

    # Document handlers.

    def expect_first_document_start(self):
        # type: () -> Any
        return self.expect_document_start(first=True)

    def expect_document_start(self, first=False):
        # type: (bool) -> None
        if isinstance(self.event, DocumentStartEvent):
            if (self.event.version or self.event.tags) and self.open_ended:
                self.write_indicator(u"...", True)
                self.write_indent()
            if self.event.version:
                version_text = self.prepare_version(self.event.version)
                self.write_version_directive(version_text)
            self.tag_prefixes = self.DEFAULT_TAG_PREFIXES.copy()
            if self.event.tags:
                handles = sorted(self.event.tags.keys())
                for handle in handles:
                    prefix = self.event.tags[handle]
                    self.tag_prefixes[prefix] = handle
                    handle_text = self.prepare_tag_handle(handle)
                    prefix_text = self.prepare_tag_prefix(prefix)
                    self.write_tag_directive(handle_text, prefix_text)
            implicit = (
                first
                and not self.event.explicit
                and not self.canonical
                and not self.event.version
                and not self.event.tags
                and not self.check_empty_document()
            )
            if not implicit:
                self.write_indent()
                self.write_indicator(u"---", True)
                if self.canonical:
                    self.write_indent()
            self.state = self.expect_document_root
        elif isinstance(self.event, StreamEndEvent):
            if self.open_ended:
                self.write_indicator(u"...", True)
                self.write_indent()
            self.write_stream_end()
            self.state = self.expect_nothing
        else:
            raise EmitterError(
                "expected DocumentStartEvent, but got %s" % (self.event,)
            )

    def expect_document_end(self):
        # type: () -> None
        if isinstance(self.event, DocumentEndEvent):
            self.write_indent()
            if self.event.explicit:
                self.write_indicator(u"...", True)
                self.write_indent()
            self.flush_stream()
            self.state = self.expect_document_start
        else:
            raise EmitterError("expected DocumentEndEvent, but got %s" % (self.event,))

    def expect_document_root(self):
        # type: () -> None
        self.states.append(self.expect_document_end)
        self.expect_node(root=True)

    # Node handlers.

    def expect_node(self, root=False, sequence=False, mapping=False, simple_key=False):
        # type: (bool, bool, bool, bool) -> None
        self.root_context = root
        self.sequence_context = sequence  # not used in PyYAML
        self.mapping_context = mapping
        self.simple_key_context = simple_key
        if isinstance(self.event, AliasEvent):
            self.expect_alias()
        elif isinstance(self.event, (ScalarEvent, CollectionStartEvent)):
            if (
                self.process_anchor(u"&")
                and isinstance(self.event, ScalarEvent)
                and self.sequence_context
            ):
                self.sequence_context = False
            if (
                root
                and isinstance(self.event, ScalarEvent)
                and not self.scalar_after_indicator
            ):
                self.write_indent()
            self.process_tag()
            if isinstance(self.event, ScalarEvent):
                # nprint('@', self.indention, self.no_newline, self.column)
                self.expect_scalar()
            elif isinstance(self.event, SequenceStartEvent):
                # nprint('@', self.indention, self.no_newline, self.column)
                i2, n2 = self.indention, self.no_newline  # NOQA
                if self.event.comment:
                    if self.event.flow_style is False and self.event.comment:
                        if self.write_post_comment(self.event):
                            self.indention = False
                            self.no_newline = True
                    if self.write_pre_comment(self.event):
                        self.indention = i2
                        self.no_newline = not self.indention
                if (
                    self.flow_level
                    or self.canonical
                    or self.event.flow_style
                    or self.check_empty_sequence()
                ):
                    self.expect_flow_sequence()
                else:
                    self.expect_block_sequence()
            elif isinstance(self.event, MappingStartEvent):
                if self.event.flow_style is False and self.event.comment:
                    self.write_post_comment(self.event)
                if self.event.comment and self.event.comment[1]:
                    self.write_pre_comment(self.event)
                if (
                    self.flow_level
                    or self.canonical
                    or self.event.flow_style
                    or self.check_empty_mapping()
                ):
                    self.expect_flow_mapping(single=self.event.nr_items == 1)
                else:
                    self.expect_block_mapping()
        else:
            raise EmitterError("expected NodeEvent, but got %s" % (self.event,))

    def expect_alias(self):
        # type: () -> None
        if self.event.anchor is None:
            raise EmitterError("anchor is not specified for alias")
        self.process_anchor(u"*")
        self.state = self.states.pop()

    def expect_scalar(self):
        # type: () -> None
        self.increase_indent(flow=True)
        self.process_scalar()
        self.indent = self.indents.pop()
        self.state = self.states.pop()

    # Flow sequence handlers.

    def expect_flow_sequence(self):
        # type: () -> None
        ind = self.indents.seq_flow_align(self.best_sequence_indent, self.column)
        self.write_indicator(u" " * ind + u"[", True, whitespace=True)
        self.increase_indent(flow=True, sequence=True)
        self.flow_context.append("[")
        self.state = self.expect_first_flow_sequence_item

    def expect_first_flow_sequence_item(self):
        # type: () -> None
        if isinstance(self.event, SequenceEndEvent):
            self.indent = self.indents.pop()
            popped = self.flow_context.pop()
            assert popped == "["
            self.write_indicator(u"]", False)
            if self.event.comment and self.event.comment[0]:
                # eol comment on empty flow sequence
                self.write_post_comment(self.event)
            elif self.flow_level == 0:
                self.write_line_break()
            self.state = self.states.pop()
        else:
            if self.canonical or self.column > self.best_width:
                self.write_indent()
            self.states.append(self.expect_flow_sequence_item)
            self.expect_node(sequence=True)

    def expect_flow_sequence_item(self):
        # type: () -> None
        if isinstance(self.event, SequenceEndEvent):
            self.indent = self.indents.pop()
            popped = self.flow_context.pop()
            assert popped == "["
            if self.canonical:
                self.write_indicator(u",", False)
                self.write_indent()
            self.write_indicator(u"]", False)
            if self.event.comment and self.event.comment[0]:
                # eol comment on flow sequence
                self.write_post_comment(self.event)
            else:
                self.no_newline = False
            self.state = self.states.pop()
        else:
            self.write_indicator(u",", False)
            if self.canonical or self.column > self.best_width:
                self.write_indent()
            self.states.append(self.expect_flow_sequence_item)
            self.expect_node(sequence=True)

    # Flow mapping handlers.

    def expect_flow_mapping(self, single=False):
        # type: (Optional[bool]) -> None
        ind = self.indents.seq_flow_align(self.best_sequence_indent, self.column)
        map_init = u"{"
        if (
            single
            and self.flow_level
            and self.flow_context[-1] == "["
            and not self.canonical
            and not self.brace_single_entry_mapping_in_flow_sequence
        ):
            # single map item with flow context, no curly braces necessary
            map_init = u""
        self.write_indicator(u" " * ind + map_init, True, whitespace=True)
        self.flow_context.append(map_init)
        self.increase_indent(flow=True, sequence=False)
        self.state = self.expect_first_flow_mapping_key

    def expect_first_flow_mapping_key(self):
        # type: () -> None
        if isinstance(self.event, MappingEndEvent):
            self.indent = self.indents.pop()
            popped = self.flow_context.pop()
            assert popped == "{"  # empty flow mapping
            self.write_indicator(u"}", False)
            if self.event.comment and self.event.comment[0]:
                # eol comment on empty mapping
                self.write_post_comment(self.event)
            elif self.flow_level == 0:
                self.write_line_break()
            self.state = self.states.pop()
        else:
            if self.canonical or self.column > self.best_width:
                self.write_indent()
            if not self.canonical and self.check_simple_key():
                self.states.append(self.expect_flow_mapping_simple_value)
                self.expect_node(mapping=True, simple_key=True)
            else:
                self.write_indicator(u"?", True)
                self.states.append(self.expect_flow_mapping_value)
                self.expect_node(mapping=True)

    def expect_flow_mapping_key(self):
        # type: () -> None
        if isinstance(self.event, MappingEndEvent):
            # if self.event.comment and self.event.comment[1]:
            #     self.write_pre_comment(self.event)
            self.indent = self.indents.pop()
            popped = self.flow_context.pop()
            assert popped in [u"{", u""]
            if self.canonical:
                self.write_indicator(u",", False)
                self.write_indent()
            if popped != u"":
                self.write_indicator(u"}", False)
            if self.event.comment and self.event.comment[0]:
                # eol comment on flow mapping, never reached on empty mappings
                self.write_post_comment(self.event)
            else:
                self.no_newline = False
            self.state = self.states.pop()
        else:
            self.write_indicator(u",", False)
            if self.canonical or self.column > self.best_width:
                self.write_indent()
            if not self.canonical and self.check_simple_key():
                self.states.append(self.expect_flow_mapping_simple_value)
                self.expect_node(mapping=True, simple_key=True)
            else:
                self.write_indicator(u"?", True)
                self.states.append(self.expect_flow_mapping_value)
                self.expect_node(mapping=True)

    def expect_flow_mapping_simple_value(self):
        # type: () -> None
        self.write_indicator(self.prefixed_colon, False)
        self.states.append(self.expect_flow_mapping_key)
        self.expect_node(mapping=True)

    def expect_flow_mapping_value(self):
        # type: () -> None
        if self.canonical or self.column > self.best_width:
            self.write_indent()
        self.write_indicator(self.prefixed_colon, True)
        self.states.append(self.expect_flow_mapping_key)
        self.expect_node(mapping=True)

    # Block sequence handlers.

    def expect_block_sequence(self):
        # type: () -> None
        if self.mapping_context:
            indentless = not self.indention
        else:
            indentless = False
            if not self.compact_seq_seq and self.column != 0:
                self.write_line_break()
        self.increase_indent(flow=False, sequence=True, indentless=indentless)
        self.state = self.expect_first_block_sequence_item

    def expect_first_block_sequence_item(self):
        # type: () -> Any
        return self.expect_block_sequence_item(first=True)

    def expect_block_sequence_item(self, first=False):
        # type: (bool) -> None
        if not first and isinstance(self.event, SequenceEndEvent):
            if self.event.comment and self.event.comment[1]:
                # final comments on a block list e.g. empty line
                self.write_pre_comment(self.event)
            self.indent = self.indents.pop()
            self.state = self.states.pop()
            self.no_newline = False
        else:
            if self.event.comment and self.event.comment[1]:
                self.write_pre_comment(self.event)
            nonl = self.no_newline if self.column == 0 else False
            self.write_indent()
            ind = self.sequence_dash_offset  # if  len(self.indents) > 1 else 0
            self.write_indicator(u" " * ind + u"-", True, indention=True)
            if nonl or self.sequence_dash_offset + 2 > self.best_sequence_indent:
                self.no_newline = True
            self.states.append(self.expect_block_sequence_item)
            self.expect_node(sequence=True)

    # Block mapping handlers.

    def expect_block_mapping(self):
        # type: () -> None
        if not self.mapping_context and not (self.compact_seq_map or self.column == 0):
            self.write_line_break()
        self.increase_indent(flow=False, sequence=False)
        self.state = self.expect_first_block_mapping_key

    def expect_first_block_mapping_key(self):
        # type: () -> None
        return self.expect_block_mapping_key(first=True)

    def expect_block_mapping_key(self, first=False):
        # type: (Any) -> None
        if not first and isinstance(self.event, MappingEndEvent):
            if self.event.comment and self.event.comment[1]:
                # final comments from a doc
                self.write_pre_comment(self.event)
            self.indent = self.indents.pop()
            self.state = self.states.pop()
        else:
            if self.event.comment and self.event.comment[1]:
                # final comments from a doc
                self.write_pre_comment(self.event)
            self.write_indent()
            if self.check_simple_key():
                if not isinstance(
                    self.event, (SequenceStartEvent, MappingStartEvent)
                ):  # sequence keys
                    try:
                        if self.event.style == "?":
                            self.write_indicator(u"?", True, indention=True)
                    except AttributeError:  # aliases have no style
                        pass
                self.states.append(self.expect_block_mapping_simple_value)
                self.expect_node(mapping=True, simple_key=True)
                if isinstance(self.event, AliasEvent):
                    self.stream.write(u" ")
            else:
                self.write_indicator(u"?", True, indention=True)
                self.states.append(self.expect_block_mapping_value)
                self.expect_node(mapping=True)

    def expect_block_mapping_simple_value(self):
        # type: () -> None
        if getattr(self.event, "style", None) != "?":
            # prefix = u''
            if self.indent == 0 and self.top_level_colon_align is not None:
                # write non-prefixed colon
                c = u" " * (self.top_level_colon_align - self.column) + self.colon
            else:
                c = self.prefixed_colon
            self.write_indicator(c, False)
        self.states.append(self.expect_block_mapping_key)
        self.expect_node(mapping=True)

    def expect_block_mapping_value(self):
        # type: () -> None
        self.write_indent()
        self.write_indicator(self.prefixed_colon, True, indention=True)
        self.states.append(self.expect_block_mapping_key)
        self.expect_node(mapping=True)

    # Checkers.

    def check_empty_sequence(self):
        # type: () -> bool
        return (
            isinstance(self.event, SequenceStartEvent)
            and bool(self.events)
            and isinstance(self.events[0], SequenceEndEvent)
        )

    def check_empty_mapping(self):
        # type: () -> bool
        return (
            isinstance(self.event, MappingStartEvent)
            and bool(self.events)
            and isinstance(self.events[0], MappingEndEvent)
        )

    def check_empty_document(self):
        # type: () -> bool
        if not isinstance(self.event, DocumentStartEvent) or not self.events:
            return False
        event = self.events[0]
        return (
            isinstance(event, ScalarEvent)
            and event.anchor is None
            and event.tag is None
            and event.implicit
            and event.value == ""
        )

    def check_simple_key(self):
        # type: () -> bool
        length = 0
        if isinstance(self.event, NodeEvent) and self.event.anchor is not None:
            if self.prepared_anchor is None:
                self.prepared_anchor = self.prepare_anchor(self.event.anchor)
            length += len(self.prepared_anchor)
        if (
            isinstance(self.event, (ScalarEvent, CollectionStartEvent))
            and self.event.tag is not None
        ):
            if self.prepared_tag is None:
                self.prepared_tag = self.prepare_tag(self.event.tag)
            length += len(self.prepared_tag)
        if isinstance(self.event, ScalarEvent):
            if self.analysis is None:
                self.analysis = self.analyze_scalar(self.event.value)
            length += len(self.analysis.scalar)
        return length < self.MAX_SIMPLE_KEY_LENGTH and (
            isinstance(self.event, AliasEvent)
            or (
                isinstance(self.event, SequenceStartEvent)
                and self.event.flow_style is True
            )
            or (
                isinstance(self.event, MappingStartEvent)
                and self.event.flow_style is True
            )
            or (
                isinstance(self.event, ScalarEvent)
                # if there is an explicit style for an empty string, it is a simple key
                and not (self.analysis.empty and self.style and self.style not in "'\"")
                and not self.analysis.multiline
            )
            or self.check_empty_sequence()
            or self.check_empty_mapping()
        )

    # Anchor, Tag, and Scalar processors.

    def process_anchor(self, indicator):
        # type: (Any) -> bool
        if self.event.anchor is None:
            self.prepared_anchor = None
            return False
        if self.prepared_anchor is None:
            self.prepared_anchor = self.prepare_anchor(self.event.anchor)
        if self.prepared_anchor:
            self.write_indicator(indicator + self.prepared_anchor, True)
            # issue 288
            self.no_newline = False
        self.prepared_anchor = None
        return True

    def process_tag(self):
        # type: () -> None
        tag = self.event.tag
        if isinstance(self.event, ScalarEvent):
            if self.style is None:
                self.style = self.choose_scalar_style()
            if (not self.canonical or tag is None) and (
                (self.style == "" and self.event.implicit[0])
                or (self.style != "" and self.event.implicit[1])
            ):
                self.prepared_tag = None
                return
            if self.event.implicit[0] and tag is None:
                tag = u"!"
                self.prepared_tag = None
        else:
            if (not self.canonical or tag is None) and self.event.implicit:
                self.prepared_tag = None
                return
        if tag is None:
            raise EmitterError("tag is not specified")
        if self.prepared_tag is None:
            self.prepared_tag = self.prepare_tag(tag)
        if self.prepared_tag:
            self.write_indicator(self.prepared_tag, True)
            if (
                self.sequence_context
                and not self.flow_level
                and isinstance(self.event, ScalarEvent)
            ):
                self.no_newline = True
        self.prepared_tag = None

    def choose_scalar_style(self):
        # type: () -> Any
        if self.analysis is None:
            self.analysis = self.analyze_scalar(self.event.value)
        if self.event.style == '"' or self.canonical:
            return '"'
        if (not self.event.style or self.event.style == "?") and (
            self.event.implicit[0] or not self.event.implicit[2]
        ):
            if not (
                self.simple_key_context
                and (self.analysis.empty or self.analysis.multiline)
            ) and (
                self.flow_level
                and self.analysis.allow_flow_plain
                or (not self.flow_level and self.analysis.allow_block_plain)
            ):
                return ""
        self.analysis.allow_block = True
        if self.event.style and self.event.style in "|>":
            if (
                not self.flow_level
                and not self.simple_key_context
                and self.analysis.allow_block
            ):
                return self.event.style
        if not self.event.style and self.analysis.allow_double_quoted:
            if "'" in self.event.value or "\n" in self.event.value:
                return '"'
        if not self.event.style or self.event.style == "'":
            if self.analysis.allow_single_quoted and not (
                self.simple_key_context and self.analysis.multiline
            ):
                return "'"
        return '"'

    def process_scalar(self):
        # type: () -> None
        if self.analysis is None:
            self.analysis = self.analyze_scalar(self.event.value)
        if self.style is None:
            self.style = self.choose_scalar_style()
        split = not self.simple_key_context
        # if self.analysis.multiline and split    \
        #         and (not self.style or self.style in '\'\"'):
        #     self.write_indent()
        # nprint('xx', self.sequence_context, self.flow_level)
        if self.sequence_context and not self.flow_level:
            self.write_indent()
        if self.style == '"':
            self.write_double_quoted(self.analysis.scalar, split)
        elif self.style == "'":
            self.write_single_quoted(self.analysis.scalar, split)
        elif self.style == ">":
            self.write_folded(self.analysis.scalar)
        elif self.style == "|":
            self.write_literal(self.analysis.scalar, self.event.comment)
        else:
            self.write_plain(self.analysis.scalar, split)
        self.analysis = None
        self.style = None
        if self.event.comment:
            self.write_post_comment(self.event)

    # Analyzers.

    def prepare_version(self, version):
        # type: (Any) -> Any
        major, minor = version
        if major != 1:
            raise EmitterError("unsupported YAML version: %d.%d" % (major, minor))
        return u"%d.%d" % (major, minor)

    def prepare_tag_handle(self, handle):
        # type: (Any) -> Any
        if not handle:
            raise EmitterError("tag handle must not be empty")
        if handle[0] != u"!" or handle[-1] != u"!":
            raise EmitterError(
                "tag handle must start and end with '!': %r" % (utf8(handle))
            )
        for ch in handle[1:-1]:
            if not (
                u"0" <= ch <= u"9"
                or u"A" <= ch <= u"Z"
                or u"a" <= ch <= u"z"
                or ch in u"-_"
            ):
                raise EmitterError(
                    "invalid character %r in the tag handle: %r"
                    % (utf8(ch), utf8(handle))
                )
        return handle

    def prepare_tag_prefix(self, prefix):
        # type: (Any) -> Any
        if not prefix:
            raise EmitterError("tag prefix must not be empty")
        chunks = []  # type: List[Any]
        start = end = 0
        if prefix[0] == u"!":
            end = 1
        ch_set = u"-;/?:@&=+$,_.~*'()[]"
        if self.dumper:
            version = getattr(self.dumper, "version", (1, 2))
            if version is None or version >= (1, 2):
                ch_set += u"#"
        while end < len(prefix):
            ch = prefix[end]
            if (
                u"0" <= ch <= u"9"
                or u"A" <= ch <= u"Z"
                or u"a" <= ch <= u"z"
                or ch in ch_set
            ):
                end += 1
            else:
                if start < end:
                    chunks.append(prefix[start:end])
                start = end = end + 1
                data = utf8(ch)
                for ch in data:
                    chunks.append(u"%%%02X" % ord(ch))
        if start < end:
            chunks.append(prefix[start:end])
        return "".join(chunks)

    def prepare_tag(self, tag):
        # type: (Any) -> Any
        if not tag:
            raise EmitterError("tag must not be empty")
        if tag == u"!":
            return tag
        handle = None
        suffix = tag
        prefixes = sorted(self.tag_prefixes.keys())
        for prefix in prefixes:
            if tag.startswith(prefix) and (prefix == u"!" or len(prefix) < len(tag)):
                handle = self.tag_prefixes[prefix]
                suffix = tag[len(prefix) :]
        chunks = []  # type: List[Any]
        start = end = 0
        ch_set = u"-;/?:@&=+$,_.~*'()[]"
        if self.dumper:
            version = getattr(self.dumper, "version", (1, 2))
            if version is None or version >= (1, 2):
                ch_set += u"#"
        while end < len(suffix):
            ch = suffix[end]
            if (
                u"0" <= ch <= u"9"
                or u"A" <= ch <= u"Z"
                or u"a" <= ch <= u"z"
                or ch in ch_set
                or (ch == u"!" and handle != u"!")
            ):
                end += 1
            else:
                if start < end:
                    chunks.append(suffix[start:end])
                start = end = end + 1
                data = utf8(ch)
                for ch in data:
                    chunks.append(u"%%%02X" % ord(ch))
        if start < end:
            chunks.append(suffix[start:end])
        suffix_text = "".join(chunks)
        if handle:
            return u"%s%s" % (handle, suffix_text)
        else:
            return u"!<%s>" % suffix_text

    def prepare_anchor(self, anchor):
        # type: (Any) -> Any
        if not anchor:
            raise EmitterError("anchor must not be empty")
        for ch in anchor:
            if not check_anchorname_char(ch):
                raise EmitterError(
                    "invalid character %r in the anchor: %r" % (utf8(ch), utf8(anchor))
                )
        return anchor

    def analyze_scalar(self, scalar):
        # type: (Any) -> Any
        # Empty scalar is a special case.
        if not scalar:
            return ScalarAnalysis(
                scalar=scalar,
                empty=True,
                multiline=False,
                allow_flow_plain=False,
                allow_block_plain=True,
                allow_single_quoted=True,
                allow_double_quoted=True,
                allow_block=False,
            )

        # Indicators and special characters.
        block_indicators = False
        flow_indicators = False
        line_breaks = False
        special_characters = False

        # Important whitespace combinations.
        leading_space = False
        leading_break = False
        trailing_space = False
        trailing_break = False
        break_space = False
        space_break = False

        # Check document indicators.
        if scalar.startswith(u"---") or scalar.startswith(u"..."):
            block_indicators = True
            flow_indicators = True

        # First character or preceded by a whitespace.
        preceeded_by_whitespace = True

        # Last character or followed by a whitespace.
        followed_by_whitespace = (
            len(scalar) == 1 or scalar[1] in u"\0 \t\r\n\x85\u2028\u2029"
        )

        # The previous character is a space.
        previous_space = False

        # The previous character is a break.
        previous_break = False

        index = 0
        while index < len(scalar):
            ch = scalar[index]

            # Check for indicators.
            if index == 0:
                # Leading indicators are special characters.
                if ch in u"#,[]{}&*!|>'\"%@`":
                    flow_indicators = True
                    block_indicators = True
                if ch in u"?:":  # ToDo
                    if self.serializer.use_version == (1, 1):
                        flow_indicators = True
                    elif len(scalar) == 1:  # single character
                        flow_indicators = True
                    if followed_by_whitespace:
                        block_indicators = True
                if ch == u"-" and followed_by_whitespace:
                    flow_indicators = True
                    block_indicators = True
            else:
                # Some indicators cannot appear within a scalar as well.
                if ch in u",[]{}":  # http://yaml.org/spec/1.2/spec.html#id2788859
                    flow_indicators = True
                if ch == u"?" and self.serializer.use_version == (1, 1):
                    flow_indicators = True
                if ch == u":":
                    if followed_by_whitespace:
                        flow_indicators = True
                        block_indicators = True
                if ch == u"#" and preceeded_by_whitespace:
                    flow_indicators = True
                    block_indicators = True

            # Check for line breaks, special, and unicode characters.
            if ch in u"\n\x85\u2028\u2029":
                line_breaks = True
            if not (ch == u"\n" or u"\x20" <= ch <= u"\x7E"):
                if (
                    ch == u"\x85"
                    or u"\xA0" <= ch <= u"\uD7FF"
                    or u"\uE000" <= ch <= u"\uFFFD"
                    or (
                        self.unicode_supplementary
                        and (u"\U00010000" <= ch <= u"\U0010FFFF")
                    )
                ) and ch != u"\uFEFF":
                    # unicode_characters = True
                    if not self.allow_unicode:
                        special_characters = True
                else:
                    special_characters = True

            # Detect important whitespace combinations.
            if ch == u" ":
                if index == 0:
                    leading_space = True
                if index == len(scalar) - 1:
                    trailing_space = True
                if previous_break:
                    break_space = True
                previous_space = True
                previous_break = False
            elif ch in u"\n\x85\u2028\u2029":
                if index == 0:
                    leading_break = True
                if index == len(scalar) - 1:
                    trailing_break = True
                if previous_space:
                    space_break = True
                previous_space = False
                previous_break = True
            else:
                previous_space = False
                previous_break = False

            # Prepare for the next character.
            index += 1
            preceeded_by_whitespace = ch in u"\0 \t\r\n\x85\u2028\u2029"
            followed_by_whitespace = (
                index + 1 >= len(scalar)
                or scalar[index + 1] in u"\0 \t\r\n\x85\u2028\u2029"
            )

        # Let's decide what styles are allowed.
        allow_flow_plain = True
        allow_block_plain = True
        allow_single_quoted = True
        allow_double_quoted = True
        allow_block = True

        # Leading and trailing whitespaces are bad for plain scalars.
        if leading_space or leading_break or trailing_space or trailing_break:
            allow_flow_plain = allow_block_plain = False

        # We do not permit trailing spaces for block scalars.
        if trailing_space:
            allow_block = False

        # Spaces at the beginning of a new line are only acceptable for block
        # scalars.
        if break_space:
            allow_flow_plain = allow_block_plain = allow_single_quoted = False

        # Spaces followed by breaks, as well as special character are only
        # allowed for double quoted scalars.
        if special_characters:
            allow_flow_plain = (
                allow_block_plain
            ) = allow_single_quoted = allow_block = False
        elif space_break:
            allow_flow_plain = allow_block_plain = allow_single_quoted = False
            if not self.allow_space_break:
                allow_block = False

        # Although the plain scalar writer supports breaks, we never emit
        # multiline plain scalars.
        if line_breaks:
            allow_flow_plain = allow_block_plain = False

        # Flow indicators are forbidden for flow plain scalars.
        if flow_indicators:
            allow_flow_plain = False

        # Block indicators are forbidden for block plain scalars.
        if block_indicators:
            allow_block_plain = False

        return ScalarAnalysis(
            scalar=scalar,
            empty=False,
            multiline=line_breaks,
            allow_flow_plain=allow_flow_plain,
            allow_block_plain=allow_block_plain,
            allow_single_quoted=allow_single_quoted,
            allow_double_quoted=allow_double_quoted,
            allow_block=allow_block,
        )

    # Writers.

    def flush_stream(self):
        # type: () -> None
        if hasattr(self.stream, "flush"):
            self.stream.flush()

    def write_stream_start(self):
        # type: () -> None
        # Write BOM if needed.
        if self.encoding and self.encoding.startswith("utf-16"):
            self.stream.write(u"\uFEFF".encode(self.encoding))

    def write_stream_end(self):
        # type: () -> None
        self.flush_stream()

    def write_indicator(
        self, indicator, need_whitespace, whitespace=False, indention=False
    ):
        # type: (Any, Any, bool, bool) -> None
        if self.whitespace or not need_whitespace:
            data = indicator
        else:
            data = u" " + indicator
        self.whitespace = whitespace
        self.indention = self.indention and indention
        self.column += len(data)
        self.open_ended = False
        if bool(self.encoding):
            data = data.encode(self.encoding)
        self.stream.write(data)

    def write_indent(self):
        # type: () -> None
        indent = self.indent or 0
        if (
            not self.indention
            or self.column > indent
            or (self.column == indent and not self.whitespace)
        ):
            if bool(self.no_newline):
                self.no_newline = False
            else:
                self.write_line_break()
        if self.column < indent:
            self.whitespace = True
            data = u" " * (indent - self.column)
            self.column = indent
            if self.encoding:
                data = data.encode(self.encoding)
            self.stream.write(data)

    def write_line_break(self, data=None):
        # type: (Any) -> None
        if data is None:
            data = self.best_line_break
        self.whitespace = True
        self.indention = True
        self.line += 1
        self.column = 0
        if bool(self.encoding):
            data = data.encode(self.encoding)
        self.stream.write(data)

    def write_version_directive(self, version_text):
        # type: (Any) -> None
        data = u"%%YAML %s" % version_text
        if self.encoding:
            data = data.encode(self.encoding)
        self.stream.write(data)
        self.write_line_break()

    def write_tag_directive(self, handle_text, prefix_text):
        # type: (Any, Any) -> None
        data = u"%%TAG %s %s" % (handle_text, prefix_text)
        if self.encoding:
            data = data.encode(self.encoding)
        self.stream.write(data)
        self.write_line_break()

    # Scalar streams.

    def write_single_quoted(self, text, split=True):
        # type: (Any, Any) -> None
        if self.root_context:
            if self.requested_indent is not None:
                self.write_line_break()
                if self.requested_indent != 0:
                    self.write_indent()
        self.write_indicator(u"'", True)
        spaces = False
        breaks = False
        start = end = 0
        while end <= len(text):
            ch = None
            if end < len(text):
                ch = text[end]
            if spaces:
                if ch is None or ch != u" ":
                    if (
                        start + 1 == end
                        and self.column > self.best_width
                        and split
                        and start != 0
                        and end != len(text)
                    ):
                        self.write_indent()
                    else:
                        data = text[start:end]
                        self.column += len(data)
                        if bool(self.encoding):
                            data = data.encode(self.encoding)
                        self.stream.write(data)
                    start = end
            elif breaks:
                if ch is None or ch not in u"\n\x85\u2028\u2029":
                    if text[start] == u"\n":
                        self.write_line_break()
                    for br in text[start:end]:
                        if br == u"\n":
                            self.write_line_break()
                        else:
                            self.write_line_break(br)
                    self.write_indent()
                    start = end
            else:
                if ch is None or ch in u" \n\x85\u2028\u2029" or ch == u"'":
                    if start < end:
                        data = text[start:end]
                        self.column += len(data)
                        if bool(self.encoding):
                            data = data.encode(self.encoding)
                        self.stream.write(data)
                        start = end
            if ch == u"'":
                data = u"''"
                self.column += 2
                if bool(self.encoding):
                    data = data.encode(self.encoding)
                self.stream.write(data)
                start = end + 1
            if ch is not None:
                spaces = ch == u" "
                breaks = ch in u"\n\x85\u2028\u2029"
            end += 1
        self.write_indicator(u"'", False)

    ESCAPE_REPLACEMENTS = {
        u"\0": u"0",
        u"\x07": u"a",
        u"\x08": u"b",
        u"\x09": u"t",
        u"\x0A": u"n",
        u"\x0B": u"v",
        u"\x0C": u"f",
        u"\x0D": u"r",
        u"\x1B": u"e",
        u'"': u'"',
        u"\\": u"\\",
        u"\x85": u"N",
        u"\xA0": u"_",
        u"\u2028": u"L",
        u"\u2029": u"P",
    }

    def write_double_quoted(self, text, split=True):
        # type: (Any, Any) -> None
        if self.root_context:
            if self.requested_indent is not None:
                self.write_line_break()
                if self.requested_indent != 0:
                    self.write_indent()
        self.write_indicator(u'"', True)
        start = end = 0
        while end <= len(text):
            ch = None
            if end < len(text):
                ch = text[end]
            if (
                ch is None
                or ch in u'"\\\x85\u2028\u2029\uFEFF'
                or not (
                    u"\x20" <= ch <= u"\x7E"
                    or (
                        self.allow_unicode
                        and (u"\xA0" <= ch <= u"\uD7FF" or u"\uE000" <= ch <= u"\uFFFD")
                    )
                )
            ):
                if start < end:
                    data = text[start:end]
                    self.column += len(data)
                    if bool(self.encoding):
                        data = data.encode(self.encoding)
                    self.stream.write(data)
                    start = end
                if ch is not None:
                    if ch in self.ESCAPE_REPLACEMENTS:
                        data = u"\\" + self.ESCAPE_REPLACEMENTS[ch]
                    elif ch <= u"\xFF":
                        data = u"\\x%02X" % ord(ch)
                    elif ch <= u"\uFFFF":
                        data = u"\\u%04X" % ord(ch)
                    else:
                        data = u"\\U%08X" % ord(ch)
                    self.column += len(data)
                    if bool(self.encoding):
                        data = data.encode(self.encoding)
                    self.stream.write(data)
                    start = end + 1
            if (
                0 < end < len(text) - 1
                and (ch == u" " or start >= end)
                and self.column + (end - start) > self.best_width
                and split
            ):
                data = text[start:end] + u"\\"
                if start < end:
                    start = end
                self.column += len(data)
                if bool(self.encoding):
                    data = data.encode(self.encoding)
                self.stream.write(data)
                self.write_indent()
                self.whitespace = False
                self.indention = False
                if text[start] == u" ":
                    data = u"\\"
                    self.column += len(data)
                    if bool(self.encoding):
                        data = data.encode(self.encoding)
                    self.stream.write(data)
            end += 1
        self.write_indicator(u'"', False)

    def determine_block_hints(self, text):
        # type: (Any) -> Any
        indent = 0
        indicator = u""
        hints = u""
        if text:
            if text[0] in u" \n\x85\u2028\u2029":
                indent = self.best_sequence_indent
                hints += text_type(indent)
            elif self.root_context:
                for end in ["\n---", "\n..."]:
                    pos = 0
                    while True:
                        pos = text.find(end, pos)
                        if pos == -1:
                            break
                        try:
                            if text[pos + 4] in " \r\n":
                                break
                        except IndexError:
                            pass
                        pos += 1
                    if pos > -1:
                        break
                if pos > 0:
                    indent = self.best_sequence_indent
            if text[-1] not in u"\n\x85\u2028\u2029":
                indicator = u"-"
            elif len(text) == 1 or text[-2] in u"\n\x85\u2028\u2029":
                indicator = u"+"
        hints += indicator
        return hints, indent, indicator

    def write_folded(self, text):
        # type: (Any) -> None
        hints, _indent, _indicator = self.determine_block_hints(text)
        self.write_indicator(u">" + hints, True)
        if _indicator == u"+":
            self.open_ended = True
        self.write_line_break()
        leading_space = True
        spaces = False
        breaks = True
        start = end = 0
        while end <= len(text):
            ch = None
            if end < len(text):
                ch = text[end]
            if breaks:
                if ch is None or ch not in u"\n\x85\u2028\u2029\a":
                    if (
                        not leading_space
                        and ch is not None
                        and ch != u" "
                        and text[start] == u"\n"
                    ):
                        self.write_line_break()
                    leading_space = ch == u" "
                    for br in text[start:end]:
                        if br == u"\n":
                            self.write_line_break()
                        else:
                            self.write_line_break(br)
                    if ch is not None:
                        self.write_indent()
                    start = end
            elif spaces:
                if ch != u" ":
                    if start + 1 == end and self.column > self.best_width:
                        self.write_indent()
                    else:
                        data = text[start:end]
                        self.column += len(data)
                        if bool(self.encoding):
                            data = data.encode(self.encoding)
                        self.stream.write(data)
                    start = end
            else:
                if ch is None or ch in u" \n\x85\u2028\u2029\a":
                    data = text[start:end]
                    self.column += len(data)
                    if bool(self.encoding):
                        data = data.encode(self.encoding)
                    self.stream.write(data)
                    if ch == u"\a":
                        if end < (len(text) - 1) and not text[end + 2].isspace():
                            self.write_line_break()
                            self.write_indent()
                            end += 2  # \a and the space that is inserted on the fold
                        else:
                            raise EmitterError(
                                "unexcpected fold indicator \\a before space"
                            )
                    if ch is None:
                        self.write_line_break()
                    start = end
            if ch is not None:
                breaks = ch in u"\n\x85\u2028\u2029"
                spaces = ch == u" "
            end += 1

    def write_literal(self, text, comment=None):
        # type: (Any, Any) -> None
        hints, _indent, _indicator = self.determine_block_hints(text)
        self.write_indicator(u"|" + hints, True)
        try:
            comment = comment[1][0]
            if comment:
                self.stream.write(comment)
        except (TypeError, IndexError):
            pass
        if _indicator == u"+":
            self.open_ended = True
        self.write_line_break()
        breaks = True
        start = end = 0
        while end <= len(text):
            ch = None
            if end < len(text):
                ch = text[end]
            if breaks:
                if ch is None or ch not in u"\n\x85\u2028\u2029":
                    for br in text[start:end]:
                        if br == u"\n":
                            self.write_line_break()
                        else:
                            self.write_line_break(br)
                    if ch is not None:
                        if self.root_context:
                            idnx = self.indent if self.indent is not None else 0
                            self.stream.write(u" " * (_indent + idnx))
                        else:
                            self.write_indent()
                    start = end
            else:
                if ch is None or ch in u"\n\x85\u2028\u2029":
                    data = text[start:end]
                    if bool(self.encoding):
                        data = data.encode(self.encoding)
                    self.stream.write(data)
                    if ch is None:
                        self.write_line_break()
                    start = end
            if ch is not None:
                breaks = ch in u"\n\x85\u2028\u2029"
            end += 1

    def write_plain(self, text, split=True):
        # type: (Any, Any) -> None
        if self.root_context:
            if self.requested_indent is not None:
                self.write_line_break()
                if self.requested_indent != 0:
                    self.write_indent()
            else:
                self.open_ended = True
        if not text:
            return
        if not self.whitespace:
            data = u" "
            self.column += len(data)
            if self.encoding:
                data = data.encode(self.encoding)
            self.stream.write(data)
        self.whitespace = False
        self.indention = False
        spaces = False
        breaks = False
        start = end = 0
        while end <= len(text):
            ch = None
            if end < len(text):
                ch = text[end]
            if spaces:
                if ch != u" ":
                    if start + 1 == end and self.column > self.best_width and split:
                        self.write_indent()
                        self.whitespace = False
                        self.indention = False
                    else:
                        data = text[start:end]
                        self.column += len(data)
                        if self.encoding:
                            data = data.encode(self.encoding)
                        self.stream.write(data)
                    start = end
            elif breaks:
                if ch not in u"\n\x85\u2028\u2029":  # type: ignore
                    if text[start] == u"\n":
                        self.write_line_break()
                    for br in text[start:end]:
                        if br == u"\n":
                            self.write_line_break()
                        else:
                            self.write_line_break(br)
                    self.write_indent()
                    self.whitespace = False
                    self.indention = False
                    start = end
            else:
                if ch is None or ch in u" \n\x85\u2028\u2029":
                    data = text[start:end]
                    self.column += len(data)
                    if self.encoding:
                        data = data.encode(self.encoding)
                    try:
                        self.stream.write(data)
                    except:  # NOQA
                        sys.stdout.write(repr(data) + "\n")
                        raise
                    start = end
            if ch is not None:
                spaces = ch == u" "
                breaks = ch in u"\n\x85\u2028\u2029"
            end += 1

    def write_comment(self, comment, pre=False):
        # type: (Any, bool) -> None
        value = comment.value
        # nprintf('{:02d} {:02d} {!r}'.format(self.column, comment.start_mark.column, value))
        if not pre and value[-1] == "\n":
            value = value[:-1]
        try:
            # get original column position
            col = comment.start_mark.column
            if comment.value and comment.value.startswith("\n"):
                # never inject extra spaces if the comment starts with a newline
                # and not a real comment (e.g. if you have an empty line following a key-value
                col = self.column
            elif col < self.column + 1:
                ValueError
        except ValueError:
            col = self.column + 1
        # nprint('post_comment', self.line, self.column, value)
        try:
            # at least one space if the current column >= the start column of the comment
            # but not at the start of a line
            nr_spaces = col - self.column
            if self.column and value.strip() and nr_spaces < 1 and value[0] != "\n":
                nr_spaces = 1
            value = " " * nr_spaces + value
            try:
                if bool(self.encoding):
                    value = value.encode(self.encoding)
            except UnicodeDecodeError:
                pass
            self.stream.write(value)
        except TypeError:
            raise
        if not pre:
            self.write_line_break()

    def write_pre_comment(self, event):
        # type: (Any) -> bool
        comments = event.comment[1]
        if comments is None:
            return False
        try:
            start_events = (MappingStartEvent, SequenceStartEvent)
            for comment in comments:
                if isinstance(event, start_events) and getattr(
                    comment, "pre_done", None
                ):
                    continue
                if self.column != 0:
                    self.write_line_break()
                self.write_comment(comment, pre=True)
                if isinstance(event, start_events):
                    comment.pre_done = True
        except TypeError:
            sys.stdout.write("eventtt {} {}".format(type(event), event))
            raise
        return True

    def write_post_comment(self, event):
        # type: (Any) -> bool
        if self.event.comment[0] is None:
            return False
        comment = event.comment[0]
        self.write_comment(comment)
        return True


text:
default_target: all
.PHONY : default_target

#=============================================================================
# Special targets provided by cmake.

# Disable implicit rules so canonical targets will work.
.SUFFIXES:

# Remove some rules from gmake that .SUFFIXES does not remove.
SUFFIXES =

.SUFFIXES: .hpux_make_needs_suffix_list

# Suppress display of executed commands.
$(VERBOSE).SILENT:

# A target that is always out of date.
cmake_force:
.PHONY : cmake_force

#=============================================================================
# Set environment variables for the build.

# The shell in which to execute make rules.
SHELL = /bin/sh

# The CMake executable.
CMAKE_COMMAND = /usr/bin/cmake

# The command to remove a file.
RM = /usr/bin/cmake -E remove -f

# Escaping for special characters.
EQUALS = =

# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/alexander/projects/Natural

# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/alexander/projects/Natural/build

#=============================================================================
# Targets provided globally by CMake.

# Special rule for the target edit_cache
edit_cache:
	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running interactive CMake command-line interface..."
	/usr/bin/cmake -i .
.PHONY : edit_cache

# Special rule for the target edit_cache
edit_cache/fast: edit_cache
.PHONY : edit_cache/fast

# Special rule for the target install
install: preinstall
	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Install the project..."
	/usr/bin/cmake -P cmake_install.cmake
.PHONY : install

# Special rule for the target install
install/fast: preinstall/fast
	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Install the project..."
	/usr/bin/cmake -P cmake_install.cmake
.PHONY : install/fast

# Special rule for the target install/local
install/local: preinstall
	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Installing only the local directory..."
	/usr/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
.PHONY : install/local

# Special rule for the target install/local
install/local/fast: install/local
.PHONY : install/local/fast

# Special rule for the target install/strip
install/strip: preinstall
	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Installing the project stripped..."
	/usr/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
.PHONY : install/strip

# Special rule for the target install/strip
install/strip/fast: install/strip
.PHONY : install/strip/fast

# Special rule for the target list_install_components
list_install_components:
	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Available install components are: \"Unspecified\""
.PHONY : list_install_components

# Special rule for the target list_install_components
list_install_components/fast: list_install_components
.PHONY : list_install_components/fast

# Special rule for the target package
package: preinstall
	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Run CPack packaging tool..."
	cd /home/alexander/projects/Natural/build && /usr/bin/cpack --config ./CPackConfig.cmake
.PHONY : package

# Special rule for the target package
package/fast: package
.PHONY : package/fast

# Special rule for the target package_source
package_source:
	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Run CPack packaging tool for source..."
	cd /home/alexander/projects/Natural/build && /usr/bin/cpack --config ./CPackSourceConfig.cmake /home/alexander/projects/Natural/build/CPackSourceConfig.cmake
.PHONY : package_source

# Special rule for the target package_source
package_source/fast: package_source
.PHONY : package_source/fast

# Special rule for the target rebuild_cache
rebuild_cache:
	@$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake to regenerate build system..."
	/usr/bin/cmake -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
.PHONY : rebuild_cache

# Special rule for the target rebuild_cache
rebuild_cache/fast: rebuild_cache
.PHONY : rebuild_cache/fast

# The main all target
all: cmake_check_build_system
	cd /home/alexander/projects/Natural/build && $(CMAKE_COMMAND) -E cmake_progress_start /home/alexander/projects/Natural/build/CMakeFiles /home/alexander/projects/Natural/build/external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/progress.marks
	cd /home/alexander/projects/Natural/build && $(MAKE) -f CMakeFiles/Makefile2 external/bullet-2.81-rev2613/src/LinearMath/all
	$(CMAKE_COMMAND) -E cmake_progress_start /home/alexander/projects/Natural/build/CMakeFiles 0
.PHONY : all

# The main clean target
clean:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f CMakeFiles/Makefile2 external/bullet-2.81-rev2613/src/LinearMath/clean
.PHONY : clean

# The main clean target
clean/fast: clean
.PHONY : clean/fast

# Prepare targets for installation.
preinstall: all
	cd /home/alexander/projects/Natural/build && $(MAKE) -f CMakeFiles/Makefile2 external/bullet-2.81-rev2613/src/LinearMath/preinstall
.PHONY : preinstall

# Prepare targets for installation.
preinstall/fast:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f CMakeFiles/Makefile2 external/bullet-2.81-rev2613/src/LinearMath/preinstall
.PHONY : preinstall/fast

# clear depends
depend:
	cd /home/alexander/projects/Natural/build && $(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
.PHONY : depend

# Convenience name for target.
external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/rule:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f CMakeFiles/Makefile2 external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/rule
.PHONY : external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/rule

# Convenience name for target.
LinearMath: external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/rule
.PHONY : LinearMath

# fast build rule for target.
LinearMath/fast:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build
.PHONY : LinearMath/fast

btAlignedAllocator.o: btAlignedAllocator.cpp.o
.PHONY : btAlignedAllocator.o

# target to build an object file
btAlignedAllocator.cpp.o:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btAlignedAllocator.cpp.o
.PHONY : btAlignedAllocator.cpp.o

btAlignedAllocator.i: btAlignedAllocator.cpp.i
.PHONY : btAlignedAllocator.i

# target to preprocess a source file
btAlignedAllocator.cpp.i:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btAlignedAllocator.cpp.i
.PHONY : btAlignedAllocator.cpp.i

btAlignedAllocator.s: btAlignedAllocator.cpp.s
.PHONY : btAlignedAllocator.s

# target to generate assembly for a file
btAlignedAllocator.cpp.s:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btAlignedAllocator.cpp.s
.PHONY : btAlignedAllocator.cpp.s

btConvexHull.o: btConvexHull.cpp.o
.PHONY : btConvexHull.o

# target to build an object file
btConvexHull.cpp.o:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btConvexHull.cpp.o
.PHONY : btConvexHull.cpp.o

btConvexHull.i: btConvexHull.cpp.i
.PHONY : btConvexHull.i

# target to preprocess a source file
btConvexHull.cpp.i:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btConvexHull.cpp.i
.PHONY : btConvexHull.cpp.i

btConvexHull.s: btConvexHull.cpp.s
.PHONY : btConvexHull.s

# target to generate assembly for a file
btConvexHull.cpp.s:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btConvexHull.cpp.s
.PHONY : btConvexHull.cpp.s

btConvexHullComputer.o: btConvexHullComputer.cpp.o
.PHONY : btConvexHullComputer.o

# target to build an object file
btConvexHullComputer.cpp.o:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btConvexHullComputer.cpp.o
.PHONY : btConvexHullComputer.cpp.o

btConvexHullComputer.i: btConvexHullComputer.cpp.i
.PHONY : btConvexHullComputer.i

# target to preprocess a source file
btConvexHullComputer.cpp.i:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btConvexHullComputer.cpp.i
.PHONY : btConvexHullComputer.cpp.i

btConvexHullComputer.s: btConvexHullComputer.cpp.s
.PHONY : btConvexHullComputer.s

# target to generate assembly for a file
btConvexHullComputer.cpp.s:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btConvexHullComputer.cpp.s
.PHONY : btConvexHullComputer.cpp.s

btGeometryUtil.o: btGeometryUtil.cpp.o
.PHONY : btGeometryUtil.o

# target to build an object file
btGeometryUtil.cpp.o:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btGeometryUtil.cpp.o
.PHONY : btGeometryUtil.cpp.o

btGeometryUtil.i: btGeometryUtil.cpp.i
.PHONY : btGeometryUtil.i

# target to preprocess a source file
btGeometryUtil.cpp.i:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btGeometryUtil.cpp.i
.PHONY : btGeometryUtil.cpp.i

btGeometryUtil.s: btGeometryUtil.cpp.s
.PHONY : btGeometryUtil.s

# target to generate assembly for a file
btGeometryUtil.cpp.s:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btGeometryUtil.cpp.s
.PHONY : btGeometryUtil.cpp.s

btPolarDecomposition.o: btPolarDecomposition.cpp.o
.PHONY : btPolarDecomposition.o

# target to build an object file
btPolarDecomposition.cpp.o:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btPolarDecomposition.cpp.o
.PHONY : btPolarDecomposition.cpp.o

btPolarDecomposition.i: btPolarDecomposition.cpp.i
.PHONY : btPolarDecomposition.i

# target to preprocess a source file
btPolarDecomposition.cpp.i:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btPolarDecomposition.cpp.i
.PHONY : btPolarDecomposition.cpp.i

btPolarDecomposition.s: btPolarDecomposition.cpp.s
.PHONY : btPolarDecomposition.s

# target to generate assembly for a file
btPolarDecomposition.cpp.s:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btPolarDecomposition.cpp.s
.PHONY : btPolarDecomposition.cpp.s

btQuickprof.o: btQuickprof.cpp.o
.PHONY : btQuickprof.o

# target to build an object file
btQuickprof.cpp.o:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btQuickprof.cpp.o
.PHONY : btQuickprof.cpp.o

btQuickprof.i: btQuickprof.cpp.i
.PHONY : btQuickprof.i

# target to preprocess a source file
btQuickprof.cpp.i:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btQuickprof.cpp.i
.PHONY : btQuickprof.cpp.i

btQuickprof.s: btQuickprof.cpp.s
.PHONY : btQuickprof.s

# target to generate assembly for a file
btQuickprof.cpp.s:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btQuickprof.cpp.s
.PHONY : btQuickprof.cpp.s

btSerializer.o: btSerializer.cpp.o
.PHONY : btSerializer.o

# target to build an object file
btSerializer.cpp.o:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btSerializer.cpp.o
.PHONY : btSerializer.cpp.o

btSerializer.i: btSerializer.cpp.i
.PHONY : btSerializer.i

# target to preprocess a source file
btSerializer.cpp.i:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btSerializer.cpp.i
.PHONY : btSerializer.cpp.i

btSerializer.s: btSerializer.cpp.s
.PHONY : btSerializer.s

# target to generate assembly for a file
btSerializer.cpp.s:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btSerializer.cpp.s
.PHONY : btSerializer.cpp.s

btVector3.o: btVector3.cpp.o
.PHONY : btVector3.o

# target to build an object file
btVector3.cpp.o:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btVector3.cpp.o
.PHONY : btVector3.cpp.o

btVector3.i: btVector3.cpp.i
.PHONY : btVector3.i

# target to preprocess a source file
btVector3.cpp.i:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btVector3.cpp.i
.PHONY : btVector3.cpp.i

btVector3.s: btVector3.cpp.s
.PHONY : btVector3.s

# target to generate assembly for a file
btVector3.cpp.s:
	cd /home/alexander/projects/Natural/build && $(MAKE) -f external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/build.make external/bullet-2.81-rev2613/src/LinearMath/CMakeFiles/LinearMath.dir/btVector3.cpp.s
.PHONY : btVector3.cpp.s

# Help Target
help:
	@echo "The following are some of the valid targets for this Makefile:"
	@echo "... all (the default if no target is provided)"
	@echo "... clean"
	@echo "... depend"
	@echo "... LinearMath"
	@echo "... edit_cache"
	@echo "... install"
	@echo "... install/local"
	@echo "... install/strip"
	@echo "... list_install_components"
	@echo "... package"
	@echo "... package_source"
	@echo "... rebuild_cache"
	@echo "... btAlignedAllocator.o"
	@echo "... btAlignedAllocator.i"
	@echo "... btAlignedAllocator.s"
	@echo "... btConvexHull.o"
	@echo "... btConvexHull.i"
	@echo "... btConvexHull.s"
	@echo "... btConvexHullComputer.o"
	@echo "... btConvexHullComputer.i"
	@echo "... btConvexHullComputer.s"
	@echo "... btGeometryUtil.o"
	@echo "... btGeometryUtil.i"
	@echo "... btGeometryUtil.s"
	@echo "... btPolarDecomposition.o"
	@echo "... btPolarDecomposition.i"
	@echo "... btPolarDecomposition.s"
	@echo "... btQuickprof.o"
	@echo "... btQuickprof.i"
	@echo "... btQuickprof.s"
	@echo "... btSerializer.o"
	@echo "... btSerializer.i"
	@echo "... btSerializer.s"
	@echo "... btVector3.o"
	@echo "... btVector3.i"
	@echo "... btVector3.s"
.PHONY : help

#=============================================================================
# Special targets to cleanup operation of make.

# Special rule to run CMake to check the build system integrity.
# No rule that depends on this can have commands that come from listfiles
# because they might be regenerated.
cmake_check_build_system:
	cd /home/alexander/projects/Natural/build && $(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
.PHONY : cmake_check_build_system

redpajama_set_name: RedPajamaGithub


text:
<?php

if (!class_exists('EGF_Customize_Manager')) :
    class EGF_Customize_Manager
    {

        /**
         * Instance of this class.
         *
         * @var      object
         * @since    1.3
         *
         */
        protected static $instance = null;

        /**
         * Slug of the plugin screen.
         *
         * @var      string
         * @since    1.3
         *
         */
        protected $plugin_screen_hook_suffix = null;

        /**
         * Plugin slug.
         *
         * @var      string
         * @since    1.3
         *
         */
        public static $slug = 'easy-google-fonts';

        /**
         * Constructor Function
         *
         * Initialize the plugin by loading admin scripts & styles and adding a
         * settings page and menu.
         *
         * @since 1.3
         * @version 1.3.1
         *
         */
        function __construct()
        {

            $this->plugin_slug = 'easy-google-fonts';
            $this->include_control_class();

            $this->register_actions();
            $this->register_filters();
        }

        /**
         * Return an instance of this class.
         *
         * @return    object    A single instance of this class.
         *
         * @since 1.3
         * @version 1.3.1
         *
         */
        public static function get_instance()
        {

            // If the single instance hasn't been set, set it now.
            if (null == self::$instance) {
                self::$instance = new self;
            }

            return self::$instance;
        }

        /**
         * Register Custom Actions
         *
         * Add any custom actions in this function.
         *
         * @since 1.3
         * @version 1.3.1
         *
         */
        public function register_actions()
        {
            add_action('customize_controls_enqueue_scripts', array($this, 'customize_controls_enqueue_scripts'));
            add_action('customize_preview_init', array($this, 'customize_live_preview_scripts'));
            add_action('customize_register', array($this, 'customize_preview_styles'));
            add_action('customize_register', array($this, 'register_controls'));
            add_action('customize_save_tt_font_theme_options', array($this, 'customize_save_tt_font_theme_options'));
            add_action('customize_save_after', array($this, 'customize_save_after'));
        }

        /**
         * Register Custom Filters
         *
         * Add any custom filters in this function.
         *
         * @since 1.3
         * @version 1.3.1
         *
         */
        public function register_filters()
        {
        }

        /**
         * Include Required Control Classes
         *
         * Only includes the classes required for this
         * control to function if they haven't been
         * loaded yet.
         *
         * @since 1.3
         * @version 1.3.1
         *
         */
        public function include_control_class()
        {

            if (!class_exists('WP_Customize_Control')) {
                include_once(ABSPATH . WPINC . '/class-wp-customize-control.php');
            }

            if (!class_exists('EGF_Font_Control')) {
                include_once(Easy_Google_Fonts::get_includes_path() . '/controls/class-egf-font-control.php');
            }
        }

        /**
         * Load All Fonts in Customizer
         *
         * Loads the required fonts as a json object for the live
         * theme previewer and customizer. By enqueuing the fonts
         * on the screen we redice the number of ajax requests which
         * increases performance dramatically.
         *
         * @return array complete list of fonts
         *
         * @since  1.3
         * @version 1.3.1
         */
        public function customize_load_all_fonts()
        {
            return EGF_Font_Utilities::get_all_fonts();
        }

        /**
         * Load Customizer Control Scripts
         *
         * Loads the required js for the custom controls in the live
         * theme previewer. This is hooked into the live previewer
         * using the action: 'customize_controls_enqueue_scripts'.
         *
         * @return void
         *
         * @since  1.2
         * @version 1.3.1
         *
         */
        public function customize_controls_enqueue_scripts()
        {

            // Load JSON Library by Douglas Crockford
            wp_enqueue_script('json2');

            wp_enqueue_script('wp-color-picker');
            wp_enqueue_script('iris');

            // Load WordPress media lightbox
            wp_enqueue_media();

            // Load js for live customizer control
            wp_deregister_script($this->plugin_slug . '-customizer-controls-js');
            wp_register_script(
                $this->plugin_slug . '-customizer-controls-js',
                Easy_Google_Fonts::get_js_url() . '/customizer-controls.js',
                array('jquery'),
                Easy_Google_Fonts::VERSION,
                false
            );
            wp_enqueue_script($this->plugin_slug . '-customizer-controls-js');

            // Load in customizer control javascript object
            $previewl10n = $this->customize_live_preview_l10n();
            wp_localize_script($this->plugin_slug . '-customizer-controls-js', 'ttFontCustomizeSettings', $previewl10n);

            $translationl10n = $this->customize_control_l10n();
            wp_localize_script($this->plugin_slug . '-customizer-controls-js', 'ttFontTranslation', $translationl10n);

            $all_fonts = $this->customize_load_all_fonts();
            wp_localize_script($this->plugin_slug . '-customizer-controls-js', 'ttFontAllFonts', $all_fonts);

        }

        /**
         * Load Customizer Live Preview Scripts
         *
         * Loads the required js for the live theme previewer. This
         * is hooked into the live previewer using the action:
         * 'customize_preview_init'. Updates options visually in the
         * live previewer without refreshing the page.
         *
         * @return void
         *
         * @since  1.3
         * @version 1.3.1
         *
         */
        public function customize_live_preview_scripts()
        {
            global $wp_customize;

            // Load JSON Library by Douglas Crockford
            wp_enqueue_script('json2');

            // Load js for live customizer control
            wp_deregister_script($this->plugin_slug . '-customizer-preview-js');
            wp_register_script(
                $this->plugin_slug . '-customizer-preview-js',
                Easy_Google_Fonts::get_js_url() . '/customizer-preview.js',
                false,
                Easy_Google_Fonts::VERSION,
                false
            );
            wp_enqueue_script($this->plugin_slug . '-customizer-preview-js');

            $previewl10n = $this->customize_live_preview_l10n();
            wp_localize_script($this->plugin_slug . '-customizer-preview-js', 'ttFontPreviewControls', $previewl10n);

            $all_fonts = $this->customize_load_all_fonts();
            wp_localize_script($this->plugin_slug . '-customizer-preview-js', 'ttFontAllFonts', $all_fonts);
        }

        /**
         * Load Customizer Styles
         *
         * Loads the required css for the live theme previewer. It is used
         * as a way to style the custom customizer controls on the live
         * preview screen. This is hooked into the live previewer using the
         * action: 'customize_register'.
         *
         * @return void
         *
         * @since  1.3
         * @version 1.3.1
         *
         */
        public function customize_preview_styles()
        {

            wp_enqueue_style('wp-color-picker');

            // Load CSS to style custom customizer controls
            wp_register_style(
                $this->plugin_slug . '-customizer-css',
                Easy_Google_Fonts::get_css_url() . '/customizer.css',
                false,
                Easy_Google_Fonts::VERSION
            );
            wp_enqueue_style($this->plugin_slug . '-customizer-css');
        }

        /**
         * Load Custom Customizer JS Object
         *
         * Major rewrite, now generates the array without
         * referencing the customizer manager, which increases
         * performance and prevents recursion.
         *
         * @return array $controls    Control properties which will be enqueues as a JSON object on the page
         *
         * @since  1.3
         * @version 1.3.1
         *
         */
        public function customize_live_preview_l10n()
        {

            $controls = array();
            $font_controls = array_merge(EGF_Register_Options::get_option_parameters(), EGF_Register_Options::get_custom_option_parameters(array()));

            foreach ($font_controls as $key => $value) {

                $controls[$key] = array(
                    'id' => $key,
                    'label' => $value['title'],
                    'type' => $value['type'],
                    'section' => 'tt_font_typography',
                    'force_styles' => $value['properties']['force_styles'],
                    'json' => array(),
                    'selector' => $value['properties']['selector'],
                    'setting' => array(
                        'capability' => 'edit_theme_options',
                        'id' => "tt_font_theme_options[{$key}]",
                        'default' => $value['default'],
                        'sanitize_callback' => '',
                        'sanitize_js_callback' => '',
                        'theme_supports' => '',
                        'transport' => $value['transport'],
                        'type' => 'option'
                    ),
                );
            }

            return $controls;
        }

        /**
         * Load Customizer Translation JS Object
         *
         * @return void
         *
         * @since  1.3
         * @version 1.3.1
         *
         */
        public function customize_control_l10n()
        {
            $translations = array(
                'themeDefault' => '— ' . __('Theme Default', 'easy-google-fonts') . ' —',

            );
            return $translations;
        }

        /**
         * Customizer Save Action Hook
         *
         * Specifically add code that you want to execute when
         * the font setting is being saved.
         *
         * @since  1.3
         * @version 1.3.1
         *
         */
        public function customize_save_tt_font_theme_options()
        {
        }

        /**
         * Customizer Save Action Hook
         *
         * Remove / refresh any stored tranients that have
         * become stale due to the user changing options.
         * This function can also be used to add any function
         * that you wish to run after the options have been
         * saved.
         *
         * @since  1.3
         * @version 1.3.1
         *
         */
        public function customize_save_after()
        {
            delete_transient('tt_font_dynamic_styles');
            delete_transient('tt_font_theme_options');
        }

        /**
         * Theme Customizer Controls Implementation
         *
         * Implement the Theme Customizer for the Theme Settings
         * in this theme.
         *
         * @link    http://ottopress.com/2012/how-to-leverage-the-theme-customizer-in-your-own-themes/	Otto
         *
         * @see final class WP_Customize_Manager    defined in \{root}\wp-includes\class-wp-customize-manager.php
         *
         * @param    object $wp_customize Object that holds the customizer data
         *
         * @since  1.3
         * @version 1.3.1
         *
         */
        public function register_controls($wp_customize)
        {

            if (!isset($wp_customize)) {
                return;
            }

            $tt_font_options = EGF_Register_Options::get_options(false);

            // Get the array of option parameters
            $option_parameters = EGF_Register_Options::get_option_parameters();

            // Get list of tabs
            $tabs = EGF_Register_Options::get_setting_tabs();

            /**
             * 1. Register Section
             *
             * Add Each Customizer Section:
             * Add each customizer section based on each $tab section
             * from EGF_Register_Options::get_setting_tabs()
             *
             */
            foreach ($tabs as $tab) {
                // Add $tab section
                $wp_customize->add_section('tt_font_' . $tab['name'], array(
                    'title' => $tab['title'],
                    'description' => $tab['description']
                ));
            }

            /**
             * 2. Add Settings to Sections
             * 3. Register Control for Each Setting
             *
             */
            $priority = 0;
            foreach ($option_parameters as $option_parameter) {
                /**
                 * Set Transport Method:
                 *
                 * Default is to reload the iframe when the option is
                 * modified in the customizer.
                 *
                 * DEVELOPER NOTE: To change the transport type for each
                 * option modify the 'transport' value for the appropriate
                 * option in the $options array found in tt_font_get_option_parameters()
                 *
                 */
                $transport = empty($option_parameter['transport']) ? 'refresh' : $option_parameter['transport'];

                /**
                 * Add Setting To Customizer:
                 *
                 * Adds $option_parameter setting to customizer
                 * further properties are registered below. The
                 * color properties are registered as separate
                 * settings for performance reasons.
                 *
                 */
                $wp_customize->add_setting('tt_font_theme_options[' . $option_parameter['name'] . ']', array(
                    'default' => $option_parameter['default'],
                    'type' => 'option',
                    'transport' => $transport,
                ));

                $wp_customize->add_setting('tt_font_theme_options[' . $option_parameter['name'] . '][font_color]', array(
                    'default' => $option_parameter['default']['font_color'],
                    'type' => 'option',
                    'transport' => $transport,
                ));

                $wp_customize->add_setting('tt_font_theme_options[' . $option_parameter['name'] . '][background_color]', array(
                    'default' => $option_parameter['default']['background_color'],
                    'type' => 'option',
                    'transport' => $transport,
                ));

                /**
                 * Section Prefix:
                 *
                 * Add the 'tt_font_' prefix to prevent namespace
                 * collisions. Removes the prefix if we are adding
                 * this option to a default WordPress section.
                 *
                 */
                $prefix = empty($option_parameter['wp_section']) ? 'tt_font_' : '';

                // Set control $priority
                $priority += 20;

                switch ($option_parameter['type']) {
                    case 'font' :
                        $wp_customize->add_control(
                            new EGF_Font_Control(
                                $wp_customize,
                                $option_parameter['name'],
                                array(
                                    'label' => $option_parameter['title'],
                                    'section' => 'tt_font_' . $option_parameter['tab'],
                                    'settings' => 'tt_font_theme_options[' . $option_parameter['name'] . ']',
                                    'priority' => $priority,
                                    'option' => $option_parameter,
                                )
                            )
                        );
                        break;

                    // Here in case we decide to implement an additional lightweight control
                    case 'font_basic':
                        break;
                }
            }

        }

    }
endif;