yaml-spec-1.2.txt

YAML Ain’t Markup Language (YAML™) Version 1.2

3^rd Edition, Patched at 2009-10-01

Oren Ben-Kiki

   <[1]oren@ben-kiki.org>

Clark Evans

   <[2]cce@clarkevans.com>

Ingy döt Net

   <[3]ingy@ingy.net>

   Latest (patched) version:
     HTML: [4]http://yaml.org/spec/1.2/spec.html
     PDF: [5]http://yaml.org/spec/1.2/spec.pdf
     PS: [6]http://yaml.org/spec/1.2/spec.ps
     Errata: [7]http://yaml.org/spec/1.2/errata.html
   Previous (original) version:
   [8]http://yaml.org/spec/1.2/2009-07-21/spec.html

   Copyright © 2001-2009 Oren Ben-Kiki, Clark Evans, Ingy döt Net
   This document may be freely copied, provided it is not modified.

   Status of this Document

   This document reflects the third version of YAML data serialization
   language. The content of the specification was arrived at by consensus
   of its authors and through user feedback on the [9]yaml-core mailing
   list. We encourage implementers to please update their software with
   support for this version.

   The primary objective of this revision is to bring YAML into compliance
   with JSON as an official subset. YAML 1.2 is compatible with 1.1 for
   most practical applications - this is a minor revision. An expected
   source of incompatibility with prior versions of YAML, especially the
   syck implementation, is the change in implicit typing rules. We have
   removed unique implicit typing rules and have updated these rules to
   align them with JSON's productions. In this version of YAML, boolean
   values may be serialized as “true” or “false”; the empty scalar as
   “null”. Unquoted numeric values are a superset of JSON's numeric
   production. Other changes in the specification were the removal of the
   Unicode line breaks and production bug fixes. We also define 3 built-in
   implicit typing rule sets: untyped, strict JSON, and a more flexible
   YAML rule set that extends JSON typing.

   The difference between late 1.0 drafts which syck 0.55 implements and
   the 1.1 revision of this specification is much more extensive. We fixed
   usability issues with the tagging syntax. In particular, the single
   exclamation was re-defined for private types and a simple prefixing
   mechanism was introduced. This revision also fixed many production edge
   cases and introduced a type repository. Therefore, there are several
   incompatibilities between syck and this revision as well.

   The list of known errors in this specification is available at
   [10]http://yaml.org/spec/1.2/errata.html. Please report errors in this
   document to the [11]yaml-core mailing list. This revision contains
   fixes for all errors known as of 2009-10-01.

   We wish to thank implementers who have tirelessly tracked earlier
   versions of this specification, and our fabulous user community whose
   feedback has both validated and clarified our direction.

   Abstract

   YAML™ (rhymes with “camel”) is a human-friendly, cross language,
   Unicode based data serialization language designed around the common
   native data types of agile programming languages. It is broadly useful
   for programming needs ranging from configuration files to Internet
   messaging to object persistence to data auditing. Together with the
   [12]Unicode standard for characters, this specification provides all
   the information necessary to understand YAML Version 1.2 and to create
   programs that process YAML information.
     __________________________________________________________________

   Table of Contents

   [13]1. Introduction

        [14]1.1. Goals
        [15]1.2. Prior Art
        [16]1.3. Relation to JSON
        [17]1.4. Relation to XML
        [18]1.5. Terminology

   [19]2. Preview

        [20]2.1. Collections
        [21]2.2. Structures
        [22]2.3. Scalars
        [23]2.4. Tags
        [24]2.5. Full Length Example

   [25]3. Processing YAML Information

        [26]3.1. Processes

              [27]3.1.1. Dump
              [28]3.1.2. Load

        [29]3.2. Information Models

              [30]3.2.1. Representation Graph

                    [31]3.2.1.1. Nodes
                    [32]3.2.1.2. Tags
                    [33]3.2.1.3. Node Comparison

              [34]3.2.2. Serialization Tree

                    [35]3.2.2.1. Keys Order
                    [36]3.2.2.2. Anchors and Aliases

              [37]3.2.3. Presentation Stream

                    [38]3.2.3.1. Node Styles
                    [39]3.2.3.2. Scalar Formats
                    [40]3.2.3.3. Comments
                    [41]3.2.3.4. Directives

        [42]3.3. Loading Failure Points

              [43]3.3.1. Well-Formed Streams and Identified Aliases
              [44]3.3.2. Resolved Tags
              [45]3.3.3. Recognized and Valid Tags
              [46]3.3.4. Available Tags

   [47]4. Syntax Conventions

        [48]4.1. Production Parameters
        [49]4.2. Production Naming Conventions

   [50]5. Characters

        [51]5.1. Character Set
        [52]5.2. Character Encodings
        [53]5.3. Indicator Characters
        [54]5.4. Line Break Characters
        [55]5.5. White Space Characters
        [56]5.6. Miscellaneous Characters
        [57]5.7. Escaped Characters

   [58]6. Basic Structures

        [59]6.1. Indentation Spaces
        [60]6.2. Separation Spaces
        [61]6.3. Line Prefixes
        [62]6.4. Empty Lines
        [63]6.5. Line Folding
        [64]6.6. Comments
        [65]6.7. Separation Lines
        [66]6.8. Directives

              [67]6.8.1. “YAML” Directives
              [68]6.8.2. “TAG” Directives

                    [69]6.8.2.1. Tag Handles
                    [70]6.8.2.2. Tag Prefixes

        [71]6.9. Node Properties

              [72]6.9.1. Node Tags
              [73]6.9.2. Node Anchors

   [74]7. Flow Styles

        [75]7.1. Alias Nodes
        [76]7.2. Empty Nodes
        [77]7.3. Flow Scalar Styles

              [78]7.3.1. Double-Quoted Style
              [79]7.3.2. Single-Quoted Style
              [80]7.3.3. Plain Style

        [81]7.4. Flow Collection Styles

              [82]7.4.1. Flow Sequences
              [83]7.4.2. Flow Mappings

        [84]7.5. Flow Nodes

   [85]8. Block Styles

        [86]8.1. Block Scalar Styles

              [87]8.1.1. Block Scalar Headers

                    [88]8.1.1.1. Block Indentation Indicator
                    [89]8.1.1.2. Block Chomping Indicator

              [90]8.1.2. Literal Style
              [91]8.1.3. Folded Style

        [92]8.2. Block Collection Styles

              [93]8.2.1. Block Sequences
              [94]8.2.2. Block Mappings
              [95]8.2.3. Block Nodes

   [96]9. YAML Character Stream

        [97]9.1. Documents

              [98]9.1.1. Document Prefix
              [99]9.1.2. Document Markers
              [100]9.1.3. Bare Documents
              [101]9.1.4. Explicit Documents
              [102]9.1.5. Directives Documents

        [103]9.2. Streams

   [104]10. Recommended Schemas

        [105]10.1. Failsafe Schema

              [106]10.1.1. Tags

                    [107]10.1.1.1. Generic Mapping
                    [108]10.1.1.2. Generic Sequence
                    [109]10.1.1.3. Generic String

              [110]10.1.2. Tag Resolution

        [111]10.2. JSON Schema

              [112]10.2.1. Tags

                    [113]10.2.1.1. Null
                    [114]10.2.1.2. Boolean
                    [115]10.2.1.3. Integer
                    [116]10.2.1.4. Floating Point

              [117]10.2.2. Tag Resolution

        [118]10.3. Core Schema

              [119]10.3.1. Tags
              [120]10.3.2. Tag Resolution

        [121]10.4. Other Schemas

   [122]Index

Chapter 1. Introduction

   “YAML Ain’t Markup Language” (abbreviated YAML) is a data serialization
   language designed to be human-friendly and work well with modern
   programming languages for common everyday tasks. This specification is
   both an introduction to the YAML language and the concepts supporting
   it, and also a complete specification of the information needed to
   develop [123]applications for processing YAML.

   Open, interoperable and readily understandable tools have advanced
   computing immensely. YAML was designed from the start to be useful and
   friendly to people working with data. It uses Unicode [124]printable
   characters, [125]some of which provide structural information and the
   rest containing the data itself. YAML achieves a unique cleanness by
   minimizing the amount of structural characters and allowing the data to
   show itself in a natural and meaningful way. For example,
   [126]indentation may be used for structure, [127]colons separate
   [128]key: value pairs, and [129]dashes are used to create “bullet”
   [130]lists.

   There are myriad flavors of [131]data structures, but they can all be
   adequately [132]represented with three basic primitives: [133]mappings
   (hashes/dictionaries), [134]sequences (arrays/lists) and [135]scalars
   (strings/numbers). YAML leverages these primitives, and adds a simple
   typing system and [136]aliasing mechanism to form a complete language
   for [137]serializing any [138]native data structure. While most
   programming languages can use YAML for data serialization, YAML excels
   in working with those languages that are fundamentally built around the
   three basic primitives. These include the new wave of agile languages
   such as Perl, Python, PHP, Ruby, and Javascript.

   There are hundreds of different languages for programming, but only a
   handful of languages for storing and transferring data. Even though its
   potential is virtually boundless, YAML was specifically created to work
   well for common use cases such as: configuration files, log files,
   interprocess messaging, cross-language data sharing, object
   persistence, and debugging of complex data structures. When data is
   easy to view and understand, programming becomes a simpler task.

1.1. Goals

   The design goals for YAML are, in decreasing priority:
    1. YAML is easily readable by humans.
    2. YAML data is portable between programming languages.
    3. YAML matches the [139]native data structures of agile languages.
    4. YAML has a consistent model to support generic tools.
    5. YAML supports one-pass processing.
    6. YAML is expressive and extensible.
    7. YAML is easy to implement and use.

1.2. Prior Art

   YAML’s initial direction was set by the data serialization and markup
   language discussions among [140]SML-DEV members. Later on, it directly
   incorporated experience from Ingy döt Net’s Perl module
   [141]Data::Denter. Since then, YAML has matured through ideas and
   support from its user community.

   YAML integrates and builds upon concepts described by [142]C,
   [143]Java, [144]Perl, [145]Python, [146]Ruby, [147]RFC0822 (MAIL),
   [148]RFC1866 (HTML), [149]RFC2045 (MIME), [150]RFC2396 (URI), [151]XML,
   [152]SAX, [153]SOAP, and [154]JSON.

   The syntax of YAML was motivated by Internet Mail (RFC0822) and remains
   partially compatible with that standard. Further, borrowing from MIME
   (RFC2045), YAML’s top-level production is a [155]stream of independent
   [156]documents, ideal for message-based distributed processing systems.

   YAML’s [157]indentation-based scoping is similar to Python’s (without
   the ambiguities caused by [158]tabs). [159]Indented blocks facilitate
   easy inspection of the data’s structure. YAML’s [160]literal style
   leverages this by enabling formatted text to be cleanly mixed within an
   [161]indented structure without troublesome [162]escaping. YAML also
   allows the use of traditional [163]indicator-based scoping similar to
   JSON’s and Perl’s. Such [164]flow content can be freely nested inside
   [165]indented blocks.

   YAML’s [166]double-quoted style uses familiar C-style [167]escape
   sequences. This enables ASCII encoding of non-[168]printable or 8-bit
   (ISO 8859-1) characters such as [169]“\x3B”. Non-[170]printable 16-bit
   Unicode and 32-bit (ISO/IEC 10646) characters are supported with
   [171]escape sequences such as [172]“\u003B” and [173]“\U0000003B”.

   Motivated by HTML’s end-of-line normalization, YAML’s [174]line folding
   employs an intuitive method of handling [175]line breaks. A single
   [176]line break is [177]folded into a single [178]space, while
   [179]empty lines are interpreted as [180]line break characters. This
   technique allows for paragraphs to be word-wrapped without affecting
   the [181]canonical form of the [182]scalar content.

   YAML’s core type system is based on the requirements of agile languages
   such as Perl, Python, and Ruby. YAML directly supports both
   [183]collections ([184]mappings, [185]sequences) and [186]scalars.
   Support for these common types enables programmers to use their
   language’s [187]native data structures for YAML manipulation, instead
   of requiring a special document object model (DOM).

   Like XML’s SOAP, YAML supports [188]serializing a graph of [189]native
   data structures through an [190]aliasing mechanism. Also like SOAP,
   YAML provides for [191]application-defined [192]types. This allows YAML
   to [193]represent rich data structures required for modern distributed
   computing. YAML provides globally unique [194]type names using a
   namespace mechanism inspired by Java’s DNS-based package naming
   convention and XML’s URI-based namespaces. In addition, YAML allows for
   private [195]types specific to a single [196]application.

   YAML was designed to support incremental interfaces that include both
   input (“getNextEvent()”) and output (“sendNextEvent()”) one-pass
   interfaces. Together, these enable YAML to support the processing of
   large [197]documents (e.g. transaction logs) or continuous [198]streams
   (e.g. feeds from a production machine).

1.3. Relation to JSON

   Both JSON and YAML aim to be human readable data interchange formats.
   However, JSON and YAML have different priorities. JSON’s foremost
   design goal is simplicity and universality. Thus, JSON is trivial to
   generate and parse, at the cost of reduced human readability. It also
   uses a lowest common denominator information model, ensuring any JSON
   data can be easily processed by every modern programming environment.

   In contrast, YAML’s foremost design goals are human readability and
   support for [199]serializing arbitrary [200]native data structures.
   Thus, YAML allows for extremely readable files, but is more complex to
   generate and parse. In addition, YAML ventures beyond the lowest common
   denominator data types, requiring more complex processing when crossing
   between different programming environments.

   YAML can therefore be viewed as a natural superset of JSON, offering
   improved human readability and a more complete information model. This
   is also the case in practice; every JSON file is also a valid YAML
   file. This makes it easy to migrate from JSON to YAML if/when the
   additional features are required.

   JSON's [201]RFC4627 requires that [202]mappings [203]keys merely
   “SHOULD” be [204]unique, while YAML insists they “MUST” be.
   Technically, YAML therefore complies with the JSON spec, choosing to
   treat duplicates as an error. In practice, since JSON is silent on the
   semantics of such duplicates, the only portable JSON files are those
   with unique keys, which are therefore valid YAML files.

   It may be useful to define a intermediate format between YAML and JSON.
   Such a format would be trivial to parse (but not very human readable),
   like JSON. At the same time, it would allow for [205]serializing
   arbitrary [206]native data structures, like YAML. Such a format might
   also serve as YAML’s "canonical format". Defining such a “YSON” format
   (YSON is a Serialized Object Notation) can be done either by enhancing
   the JSON specification or by restricting the YAML specification. Such a
   definition is beyond the scope of this specification.

1.4. Relation to XML

   Newcomers to YAML often search for its correlation to the eXtensible
   Markup Language (XML). Although the two languages may actually compete
   in several application domains, there is no direct correlation between
   them.

   YAML is primarily a data serialization language. XML was designed to be
   backwards compatible with the Standard Generalized Markup Language
   (SGML), which was designed to support structured documentation. XML
   therefore had many design constraints placed on it that YAML does not
   share. XML is a pioneer in many domains, YAML is the result of lessons
   learned from XML and other technologies.

   It should be mentioned that there are ongoing efforts to define
   standard XML/YAML mappings. This generally requires that a subset of
   each language be used. For more information on using both XML and YAML,
   please visit [207]http://yaml.org/xml.

1.5. Terminology

   This specification uses key words based on [208]RFC2119 to indicate
   requirement level. In particular, the following words are used to
   describe the actions of a YAML [209]processor:

   May
          The word may, or the adjective optional, mean that conforming
          YAML [210]processors are permitted to, but need not behave as
          described.

   Should
          The word should, or the adjective recommended, mean that there
          could be reasons for a YAML [211]processor to deviate from the
          behavior described, but that such deviation could hurt
          interoperability and should therefore be advertised with
          appropriate notice.

   Must
          The word must, or the term required or shall, mean that the
          behavior described is an absolute requirement of the
          specification.

   The rest of this document is arranged as follows. Chapter [212]2
   provides a short preview of the main YAML features. Chapter [213]3
   describes the YAML information model, and the processes for converting
   from and to this model and the YAML text format. The bulk of the
   document, chapters [214]4 through [215]9, formally define this text
   format. Finally, chapter [216]10 recommends basic YAML schemas.

Chapter 2. Preview

   This section provides a quick glimpse into the expressive power of
   YAML. It is not expected that the first-time reader grok all of the
   examples. Rather, these selections are used as motivation for the
   remainder of the specification.

2.1. Collections

   YAML’s [217]block collections use [218]indentation for scope and begin
   each entry on its own line. [219]Block sequences indicate each entry
   with a dash and space ( [220]“- ”). [221]Mappings use a colon and
   space ([222]“: ”) to mark each [223]key: value pair. [224]Comments
   begin with an octothorpe (also called a “hash”, “sharp”, “pound”, or
   “number sign” - [225]“#”).

   Example 2.1.  Sequence of Scalars
   (ball players)
- Mark McGwire
- Sammy Sosa
- Ken Griffey

   Example 2.2.  Mapping Scalars to Scalars
   (player statistics)
hr:  65    # Home runs
avg: 0.278 # Batting average
rbi: 147   # Runs Batted In

   Example 2.3.  Mapping Scalars to Sequences
   (ball clubs in each league)
american:
  - Boston Red Sox
  - Detroit Tigers
  - New York Yankees
national:
  - New York Mets
  - Chicago Cubs
  - Atlanta Braves

   Example 2.4.  Sequence of Mappings
   (players’ statistics)
-
  name: Mark McGwire
  hr:   65
  avg:  0.278
-
  name: Sammy Sosa
  hr:   63
  avg:  0.288

   YAML also has [226]flow styles, using explicit [227]indicators rather
   than [228]indentation to denote scope. The [229]flow sequence is
   written as a [230]comma separated list within [231]square
   [232]brackets. In a similar manner, the [233]flow mapping uses
   [234]curly [235]braces.

   Example 2.5. Sequence of Sequences
- [name        , hr, avg  ]
- [Mark McGwire, 65, 0.278]
- [Sammy Sosa  , 63, 0.288]



   Example 2.6. Mapping of Mappings
Mark McGwire: {hr: 65, avg: 0.278}
Sammy Sosa: {
    hr: 63,
    avg: 0.288
  }

2.2. Structures

   YAML uses three dashes ([236]“---”) to separate [237]directives from
   [238]document [239]content. This also serves to signal the start of a
   document if no [240]directives are present. Three dots ( [241]“...”)
   indicate the end of a document without starting a new one, for use in
   communication channels.

   Example 2.7.  Two Documents in a Stream
   (each with a leading comment)
# Ranking of 1998 home runs
---
- Mark McGwire
- Sammy Sosa
- Ken Griffey

# Team ranking
---
- Chicago Cubs
- St Louis Cardinals

   Example 2.8.  Play by Play Feed
   from a Game
---
time: 20:03:20
player: Sammy Sosa
action: strike (miss)
...
---
time: 20:03:47
player: Sammy Sosa
action: grand slam
...

   Repeated [242]nodes (objects) are first [243]identified by an
   [244]anchor (marked with the ampersand - [245]“&”), and are then
   [246]aliased (referenced with an asterisk - [247]“*”) thereafter.

   Example 2.9.  Single Document with
   Two Comments
---
hr: # 1998 hr ranking
  - Mark McGwire
  - Sammy Sosa
rbi:
  # 1998 rbi ranking
  - Sammy Sosa
  - Ken Griffey

   Example 2.10.  Node for “Sammy Sosa”
   appears twice in this document
---
hr:
  - Mark McGwire
  # Following node labeled SS
  - &SS Sammy Sosa
rbi:
  - *SS # Subsequent occurrence
  - Ken Griffey

   A question mark and space ([248]“? ”) indicate a complex [249]mapping
   [250]key. Within a [251]block collection, [252]key: value pairs can
   start immediately following the [253]dash, [254]colon, or [255]question
   mark.

   Example 2.11. Mapping between Sequences
? - Detroit Tigers
  - Chicago cubs
:
  - 2001-07-23

? [ New York Yankees,
    Atlanta Braves ]
: [ 2001-07-02, 2001-08-12,
    2001-08-14 ]

   Example 2.12. Compact Nested Mapping
---
# Products purchased
- item    : Super Hoop
  quantity: 1
- item    : Basketball
  quantity: 4
- item    : Big Shoes
  quantity: 1


2.3. Scalars

   [256]Scalar content can be written in [257]block notation, using a
   [258]literal style (indicated by [259]“|”) where all [260]line breaks
   are significant. Alternatively, they can be written with the
   [261]folded style [262](denoted by “>”) where each [263]line break is
   [264]folded to a [265]space unless it ends an [266]empty or a
   [267]more-indented line.

   Example 2.13.  In literals,
   newlines are preserved
# ASCII Art
--- |
  \//||\/||
  // ||  ||__

   Example 2.14.  In the folded scalars,
   newlines become spaces
--- >
  Mark McGwire's
  year was crippled
  by a knee injury.

   Example 2.15.  Folded newlines are preserved
   for "more indented" and blank lines
>
 Sammy Sosa completed another
 fine season with great stats.

   63 Home Runs
   0.288 Batting Average

 What a year!

   Example 2.16.  Indentation determines scope

name: Mark McGwire
accomplishment: >
  Mark set a major league
  home run record in 1998.
stats: |
  65 Home Runs
  0.278 Batting Average


   YAML’s [268]flow scalars include the [269]plain style (most examples
   thus far) and two quoted styles. The [270]double-quoted style provides
   [271]escape sequences. The [272]single-quoted style is useful when
   [273]escaping is not needed. All [274]flow scalars can span multiple
   lines; [275]line breaks are always [276]folded.

   Example 2.17. Quoted Scalars
unicode: "Sosa did fine.\u263A"
control: "\b1998\t1999\t2000\n"
hex esc: "\x0d\x0a is \r\n"

single: '"Howdy!" he cried.'
quoted: ' # Not a ''comment''.'
tie-fighter: '|\-*-/|'

   Example 2.18. Multi-line Flow Scalars
plain:
  This unquoted scalar
  spans many lines.

quoted: "So does this
  quoted scalar.\n"


2.4. Tags

   In YAML, [277]untagged nodes are given a type depending on the
   [278]application. The examples in this specification generally use the
   [279]seq, [280]map and [281]str types from the [282]fail safe schema. A
   few examples also use the [283]int, [284]float, and [285]null types
   from the [286]JSON schema. The [287]repository includes additional
   types such as [288]binary, [289]omap, [290]set and others.

   Example 2.19. Integers
canonical: 12345
decimal: +12345
octal: 0o14
hexadecimal: 0xC


   Example 2.20. Floating Point
canonical: 1.23015e+3
exponential: 12.3015e+02
fixed: 1230.15
negative infinity: -.inf
not a number: .NaN

   Example 2.21. Miscellaneous
null:
booleans: [ true, false ]
string: '012345'

   Example 2.22. Timestamps
canonical: 2001-12-15T02:59:43.1Z
iso8601: 2001-12-14t21:59:43.10-05:00
spaced: 2001-12-14 21:59:43.10 -5
date: 2002-12-14

   Explicit typing is denoted with a [291]tag using the exclamation point
   ([292]“!”) symbol. [293]Global tags are URIs and may be specified in a
   [294]tag shorthand notation using a [295]handle.
   [296]Application-specific [297]local tags may also be used.

   Example 2.23. Various Explicit Tags
---
not-date: !!str 2002-04-28

picture: !!binary |
 R0lGODlhDAAMAIQAAP//9/X
 17unp5WZmZgAAAOfn515eXv
 Pz7Y6OjuDg4J+fn5OTk6enp
 56enmleECcgggoBADs=

application specific tag: !something |
 The semantics of the tag
 above may be different for
 different documents.


   Example 2.24. Global Tags
%TAG ! tag:clarkevans.com,2002:
--- !shape
  # Use the ! handle for presenting
  # tag:clarkevans.com,2002:circle
- !circle
  center: &ORIGIN {x: 73, y: 129}
  radius: 7
- !line
  start: *ORIGIN
  finish: { x: 89, y: 102 }
- !label
  start: *ORIGIN
  color: 0xFFEEBB
  text: Pretty vector drawing.

   Example 2.25. Unordered Sets
# Sets are represented as a
# Mapping where each key is
# associated with a null value
--- !!set
? Mark McGwire
? Sammy Sosa
? Ken Griff

   Example 2.26. Ordered Mappings
# Ordered maps are represented as
# A sequence of mappings, with
# each mapping having one key
--- !!omap
- Mark McGwire: 65
- Sammy Sosa: 63
- Ken Griffy: 58

2.5. Full Length Example

   Below are two full-length examples of YAML. On the left is a sample
   invoice; on the right is a sample log file.

   Example 2.27. Invoice
--- !<tag:clarkevans.com,2002:invoice>
invoice: 34843
date   : 2001-01-23
bill-to: &id001
    given  : Chris
    family : Dumars
    address:
        lines: |
            458 Walkman Dr.
            Suite #292
        city    : Royal Oak
        state   : MI
        postal  : 48046
ship-to: *id001
product:
    - sku         : BL394D
      quantity    : 4
      description : Basketball
      price       : 450.00
    - sku         : BL4438H
      quantity    : 1
      description : Super Hoop
      price       : 2392.00
tax  : 251.42
total: 4443.52
comments:
    Late afternoon is best.
    Backup contact is Nancy
    Billsmer @ 338-4338.

   Example 2.28. Log File
---
Time: 2001-11-23 15:01:42 -5
User: ed
Warning:
  This is an error message
  for the log file
---
Time: 2001-11-23 15:02:31 -5
User: ed
Warning:
  A slightly different error
  message.
---
Date: 2001-11-23 15:03:17 -5
User: ed
Fatal:
  Unknown variable "bar"
Stack:
  - file: TopClass.py
    line: 23
    code: |
      x = MoreObject("345\n")
  - file: MoreClass.py
    line: 58
    code: |-
      foo = bar




Chapter 3. Processing YAML Information

   YAML is both a text format and a method for [298]presenting any
   [299]native data structure in this format. Therefore, this
   specification defines two concepts: a class of data objects called YAML
   [300]representations, and a syntax for [301]presenting YAML
   [302]representations as a series of characters, called a YAML
   [303]stream. A YAML processor is a tool for converting information
   between these complementary views. It is assumed that a YAML processor
   does its work on behalf of another module, called an application. This
   chapter describes the information structures a YAML processor must
   provide to or obtain from the application.

   YAML information is used in two ways: for machine processing, and for
   human consumption. The challenge of reconciling these two perspectives
   is best done in three distinct translation stages: [304]representation,
   [305]serialization, and [306]presentation. [307]Representation
   addresses how YAML views [308]native data structures to achieve
   portability between programming environments. [309]Serialization
   concerns itself with turning a YAML [310]representation into a serial
   form, that is, a form with sequential access constraints.
   [311]Presentation deals with the formatting of a YAML
   [312]serialization as a series of characters in a human-friendly
   manner.

3.1. Processes

   Translating between [313]native data structures and a character
   [314]stream is done in several logically distinct stages, each with a
   well defined input and output data model, as shown in the following
   diagram:

   Figure 3.1. Processing Overview
   Processing Overview

   A YAML processor need not expose the [315]serialization or
   [316]representation stages. It may translate directly between
   [317]native data structures and a character [318]stream ([319]dump and
   [320]load in the diagram above). However, such a direct translation
   should take place so that the [321]native data structures are
   [322]constructed only from information available in the
   [323]representation. In particular, [324]mapping key order,
   [325]comments, and [326]tag handles should not be referenced during
   [327]composition.

3.1.1. Dump

   Dumping native data structures to a character [328]stream is done using
   the following three stages:

   Representing Native Data Structures
          YAML represents any native data structure using three [329]node
          kinds: [330]sequence - an ordered series of entries;
          [331]mapping - an unordered association of [332]unique [333]keys
          to [334]values; and [335]scalar - any datum with opaque
          structure presentable as a series of Unicode characters.
          Combined, these primitives generate directed graph structures.
          These primitives were chosen because they are both powerful and
          familiar: the [336]sequence corresponds to a Perl array and a
          Python list, the [337]mapping corresponds to a Perl hash table
          and a Python dictionary. The [338]scalar represents strings,
          integers, dates, and other atomic data types.

          Each YAML [339]node requires, in addition to its [340]kind and
          [341]content, a [342]tag specifying its data type. Type
          specifiers are either [343]global URIs, or are [344]local in
          scope to a single [345]application. For example, an integer is
          represented in YAML with a [346]scalar plus the [347]global tag
          “tag:yaml.org,2002:int”. Similarly, an invoice object,
          particular to a given organization, could be represented as a
          [348]mapping together with the [349]local tag “!invoice”. This
          simple model can represent any data structure independent of
          programming language.

   Serializing the Representation Graph
          For sequential access mediums, such as an event callback API, a
          YAML [350]representation must be serialized to an ordered tree.
          Since in a YAML [351]representation, [352]mapping keys are
          unordered and [353]nodes may be referenced more than once (have
          more than one incoming “arrow”), the serialization process is
          required to impose an [354]ordering on the [355]mapping keys and
          to replace the second and subsequent references to a given
          [356]node with place holders called [357]aliases. YAML does not
          specify how these serialization details are chosen. It is up to
          the YAML [358]processor to come up with human-friendly [359]key
          order and [360]anchor names, possibly with the help of the
          [361]application. The result of this process, a YAML
          [362]serialization tree, can then be traversed to produce a
          series of event calls for one-pass processing of YAML data.

   Presenting the Serialization Tree
          The final output process is presenting the YAML
          [363]serializations as a character [364]stream in a
          human-friendly manner. To maximize human readability, YAML
          offers a rich set of stylistic options which go far beyond the
          minimal functional needs of simple data storage. Therefore the
          YAML [365]processor is required to introduce various
          presentation details when creating the [366]stream, such as the
          choice of [367]node styles, how to [368]format scalar content,
          the amount of [369]indentation, which [370]tag handles to use,
          the [371]node tags to leave [372]unspecified, the set of
          [373]directives to provide and possibly even what [374]comments
          to add. While some of this can be done with the help of the
          [375]application, in general this process should be guided by
          the preferences of the user.

3.1.2. Load

   Loading [376]native data structures from a character [377]stream is
   done using the following three stages:

   Parsing the Presentation Stream
          Parsing is the inverse process of [378]presentation, it takes a
          [379]stream of characters and produces a series of events.
          Parsing discards all the [380]details introduced in the
          [381]presentation process, reporting only the [382]serialization
          events. Parsing can fail due to [383]ill-formed input.

   Composing the Representation Graph
          Composing takes a series of [384]serialization events and
          produces a [385]representation graph. Composing discards all the
          [386]details introduced in the [387]serialization process,
          producing only the [388]representation graph. Composing can fail
          due to any of several reasons, detailed [389]below.

   Constructing Native Data Structures
          The final input process is constructing [390]native data
          structures from the YAML [391]representation. Construction must
          be based only on the information available in the
          [392]representation, and not on additional [393]serialization or
          [394]presentation details such as [395]comments,
          [396]directives, [397]mapping key order, [398]node styles,
          [399]scalar content format, [400]indentation levels etc.
          Construction can fail due to the [401]unavailability of the
          required [402]native data types.

3.2. Information Models

   This section specifies the formal details of the results of the above
   processes. To maximize data portability between programming languages
   and implementations, users of YAML should be mindful of the distinction
   between [403]serialization or [404]presentation properties and those
   which are part of the YAML [405]representation. Thus, while imposing a
   [406]order on [407]mapping keys is necessary for flattening YAML
   [408]representations to a sequential access medium, this
   [409]serialization detail must not be used to convey [410]application
   level information. In a similar manner, while [411]indentation
   technique and a choice of a [412]node style are needed for the human
   readability, these [413]presentation details are neither part of the
   YAML [414]serialization nor the YAML [415]representation. By carefully
   separating properties needed for [416]serialization and
   [417]presentation, YAML [418]representations of [419]application
   information will be consistent and portable between various programming
   environments.

   The following diagram summarizes the three information models. Full
   arrows denote composition, hollow arrows denote inheritance, “1” and
   “*” denote “one” and “many” relationships. A single “+” denotes
   [420]serialization details, a double “++” denotes [421]presentation
   details.

   Figure 3.2. Information Models
   Information Models

3.2.1. Representation Graph

   YAML’s representation of [422]native data structure is a rooted,
   connected, directed graph of [423]tagged [424]nodes. By “directed
   graph” we mean a set of [425]nodes and directed edges (“arrows”), where
   each edge connects one [426]node to another (see [427]a formal
   definition). All the [428]nodes must be reachable from the root node
   via such edges. Note that the YAML graph may include cycles, and a
   [429]node may have more than one incoming edge.

   [430]Nodes that are defined in terms of other [431]nodes are
   [432]collections; [433]nodes that are independent of any other
   [434]nodes are [435]scalars. YAML supports two [436]kinds of
   [437]collection nodes: [438]sequences and [439]mappings. [440]Mapping
   nodes are somewhat tricky because their [441]keys are unordered and
   must be [442]unique.

   Figure 3.3. Representation Model
   Representation Model

3.2.1.1. Nodes

   A YAML node [443]represents a single [444]native data structure. Such
   nodes have content of one of three kinds: scalar, sequence, or mapping.
   In addition, each node has a [445]tag which serves to restrict the set
   of possible values the content can have.

   Scalar
          The content of a scalar node is an opaque datum that can be
          [446]presented as a series of zero or more Unicode characters.

   Sequence
          The content of a sequence node is an ordered series of zero or
          more nodes. In particular, a sequence may contain the same node
          more than once. It could even contain itself (directly or
          indirectly).

   Mapping
          The content of a mapping node is an unordered set of key: value
          node pairs, with the restriction that each of the keys is
          [447]unique. YAML places no further restrictions on the nodes.
          In particular, keys may be arbitrary nodes, the same node may be
          used as the value of several key: value pairs, and a mapping
          could even contain itself as a key or a value (directly or
          indirectly).

   When appropriate, it is convenient to consider sequences and mappings
   together, as collections. In this view, sequences are treated as
   mappings with integer keys starting at zero. Having a unified
   collections view for sequences and mappings is helpful both for
   theoretical analysis and for creating practical YAML tools and APIs.
   This strategy is also used by the Javascript programming language.

3.2.1.2. Tags

   YAML [448]represents type information of [449]native data structures
   with a simple identifier, called a tag. Global tags are [450]URIs and
   hence globally unique across all [451]applications. The “tag:” [452]URI
   scheme is recommended for all global YAML tags. In contrast, local tags
   are specific to a single [453]application. Local tags start with “!”,
   are not URIs and are not expected to be globally unique. YAML provides
   a [454]“TAG” directive to make tag notation less verbose; it also
   offers easy migration from local to global tags. To ensure this, local
   tags are restricted to the URI character set and use URI character
   [455]escaping.

   YAML does not mandate any special relationship between different tags
   that begin with the same substring. Tags ending with URI fragments
   (containing “#”) are no exception; tags that share the same base URI
   but differ in their fragment part are considered to be different,
   independent tags. By convention, fragments are used to identify
   different “variants” of a tag, while “/” is used to define nested tag
   “namespace” hierarchies. However, this is merely a convention, and each
   tag may employ its own rules. For example, Perl tags may use “::” to
   express namespace hierarchies, Java tags may use “.”, etc.

   YAML tags are used to associate meta information with each [456]node.
   In particular, each tag must specify the expected [457]node kind
   ([458]scalar, [459]sequence, or [460]mapping). [461]Scalar tags must
   also provide a mechanism for converting [462]formatted content to a
   [463]canonical form for supporting [464]equality testing. Furthermore,
   a tag may provide additional information such as the set of allowed
   [465]content values for validation, a mechanism for [466]tag
   resolution, or any other data that is applicable to all of the tag’s
   [467]nodes.

3.2.1.3. Node Comparison

   Since YAML [468]mappings require [469]key uniqueness,
   [470]representations must include a mechanism for testing the equality
   of [471]nodes. This is non-trivial since YAML allows various ways to
   [472]format scalar content. For example, the integer eleven can be
   written as “0o13” (octal) or “0xB” (hexadecimal). If both notations are
   used as [473]keys in the same [474]mapping, only a YAML [475]processor
   which recognizes integer [476]formats would correctly flag the
   duplicate [477]key as an error.

   Canonical Form
          YAML supports the need for [478]scalar equality by requiring
          that every [479]scalar [480]tag must specify a mechanism for
          producing the canonical form of any [481]formatted content. This
          form is a Unicode character string which also [482]presents the
          same [483]content, and can be used for equality testing. While
          this requirement is stronger than a well defined equality
          operator, it has other uses, such as the production of digital
          signatures.

   Equality
          Two [484]nodes must have the same [485]tag and [486]content to
          be equal. Since each [487]tag applies to exactly one [488]kind,
          this implies that the two [489]nodes must have the same
          [490]kind to be equal. Two [491]scalars are equal only when
          their [492]tags and canonical forms are equal
          character-by-character. Equality of [493]collections is defined
          recursively. Two [494]sequences are equal only when they have
          the same [495]tag and length, and each [496]node in one
          [497]sequence is equal to the corresponding [498]node in the
          other [499]sequence. Two [500]mappings are equal only when they
          have the same [501]tag and an equal set of [502]keys, and each
          [503]key in this set is associated with equal [504]values in
          both [505]mappings.

          Different URI schemes may define different rules for testing the
          equality of URIs. Since a YAML [506]processor cannot be
          reasonably expected to be aware of them all, it must resort to a
          simple character-by-character comparison of [507]tags to ensure
          consistency. This also happens to be the comparison method
          defined by the “tag:” URI scheme. [508]Tags in a YAML stream
          must therefore be [509]presented in a canonical way so that such
          comparison would yield the correct results.

   Identity
          Two [510]nodes are identical only when they [511]represent the
          same [512]native data structure. Typically, this corresponds to
          a single memory address. Identity should not be confused with
          equality; two equal [513]nodes need not have the same identity.
          A YAML [514]processor may treat equal [515]scalars as if they
          were identical. In contrast, the separate identity of two
          distinct but equal [516]collections must be preserved.

3.2.2. Serialization Tree

   To express a YAML [517]representation using a serial API, it is
   necessary to impose an [518]order on [519]mapping keys and employ
   [520]alias nodes to indicate a subsequent occurrence of a previously
   encountered [521]node. The result of this process is a serialization
   tree, where each [522]node has an ordered set of children. This tree
   can be traversed for a serial event-based API. [523]Construction of
   [524]native data structures from the serial interface should not use
   [525]key order or [526]anchor names for the preservation of
   [527]application data.

   Figure 3.4. Serialization Model
   Serialization Model

3.2.2.1. Keys Order

   In the [528]representation model, [529]mapping keys do not have an
   order. To [530]serialize a [531]mapping, it is necessary to impose an
   ordering on its [532]keys. This order is a [533]serialization detail
   and should not be used when [534]composing the [535]representation
   graph (and hence for the preservation of [536]application data). In
   every case where [537]node order is significant, a [538]sequence must
   be used. For example, an ordered [539]mapping can be [540]represented
   as a [541]sequence of [542]mappings, where each [543]mapping is a
   single [544]key: value pair. YAML provides convenient [545]compact
   notation for this case.

3.2.2.2. Anchors and Aliases

   In the [546]representation graph, a [547]node may appear in more than
   one [548]collection. When [549]serializing such data, the first
   occurrence of the [550]node is identified by an anchor. Each subsequent
   occurrence is [551]serialized as an [552]alias node which refers back
   to this anchor. Otherwise, anchor names are a [553]serialization detail
   and are discarded once [554]composing is completed. When [555]composing
   a [556]representation graph from [557]serialized events, an alias node
   refers to the most recent [558]node in the [559]serialization having
   the specified anchor. Therefore, anchors need not be unique within a
   [560]serialization. In addition, an anchor need not have an alias node
   referring to it. It is therefore possible to provide an anchor for all
   [561]nodes in [562]serialization.

3.2.3. Presentation Stream

   A YAML presentation is a [563]stream of Unicode characters making use
   of of [564]styles, [565]scalar content formats, [566]comments,
   [567]directives and other [568]presentation details to [569]present a
   YAML [570]serialization in a human readable way. Although a YAML
   [571]processor may provide these [572]details when [573]parsing, they
   should not be reflected in the resulting [574]serialization. YAML
   allows several [575]serialization trees to be contained in the same
   YAML character stream, as a series of [576]documents separated by
   [577]markers. Documents appearing in the same stream are independent;
   that is, a [578]node must not appear in more than one
   [579]serialization tree or [580]representation graph.

   Figure 3.5. Presentation Model
   Presentation Model

3.2.3.1. Node Styles

   Each [581]node is presented in some style, depending on its [582]kind.
   The node style is a [583]presentation detail and is not reflected in
   the [584]serialization tree or [585]representation graph. There are two
   groups of styles. [586]Block styles use [587]indentation to denote
   structure; In contrast, [588]flow styles styles rely on explicit
   [589]indicators.

   YAML provides a rich set of scalar styles. [590]Block scalar styles
   include the [591]literal style and the [592]folded style. [593]Flow
   scalar styles include the [594]plain style and two quoted styles, the
   [595]single-quoted style and the [596]double-quoted style. These styles
   offer a range of trade-offs between expressive power and readability.

   Normally, [597]block sequences and [598]mappings begin on the next
   line. In some cases, YAML also allows nested [599]block
   [600]collections to start in-line for a more [601]compact notation. In
   addition, YAML provides a [602]compact notation for [603]flow mappings
   with a single [604]key: value pair, nested inside a [605]flow sequence.
   These allow for a natural “ordered mapping” notation.

   Figure 3.6. Kind/Style Combinations
   Kind/Style Combinations

3.2.3.2. Scalar Formats

   YAML allows [606]scalars to be [607]presented in several formats. For
   example, the integer “11” might also be written as “0xB”. [608]Tags
   must specify a mechanism for converting the formatted content to a
   [609]canonical form for use in [610]equality testing. Like [611]node
   style, the format is a [612]presentation detail and is not reflected in
   the [613]serialization tree and [614]representation graph.

3.2.3.3. Comments

   [615]Comments are a [616]presentation detail and must not have any
   effect on the [617]serialization tree or [618]representation graph. In
   particular, comments are not associated with a particular [619]node.
   The usual purpose of a comment is to communicate between the human
   maintainers of a file. A typical example is comments in a configuration
   file. Comments must not appear inside [620]scalars, but may be
   interleaved with such [621]scalars inside [622]collections.

3.2.3.4. Directives

   Each [623]document may be associated with a set of [624]directives. A
   directive has a name and an optional sequence of parameters. Directives
   are instructions to the YAML [625]processor, and like all other
   [626]presentation details are not reflected in the YAML
   [627]serialization tree or [628]representation graph. This version of
   YAML defines a two directives, [629]“YAML” and [630]“TAG”. All other
   directives are [631]reserved for future versions of YAML.

3.3. Loading Failure Points

   The process of [632]loading [633]native data structures from a YAML
   [634]stream has several potential failure points. The character
   [635]stream may be [636]ill-formed, [637]aliases may be
   [638]unidentified, [639]unspecified tags may be [640]unresolvable,
   [641]tags may be [642]unrecognized, the [643]content may be
   [644]invalid, and a native type may be [645]unavailable. Each of these
   failures results with an incomplete loading.

   A partial representation need not [646]resolve the [647]tag of each
   [648]node, and the [649]canonical form of [650]formatted scalar content
   need not be available. This weaker representation is useful for cases
   of incomplete knowledge of the types used in the [651]document. In
   contrast, a complete representation specifies the [652]tag of each
   [653]node, and provides the [654]canonical form of [655]formatted
   scalar content, allowing for [656]equality testing. A complete
   representation is required in order to [657]construct [658]native data
   structures.

   Figure 3.7. Loading Failure Points
   Loading Failure Points

3.3.1. Well-Formed Streams and Identified Aliases

   A [659]well-formed character [660]stream must match the BNF productions
   specified in the following chapters. Successful loading also requires
   that each [661]alias shall refer to a previous [662]node
   [663]identified by the [664]anchor. A YAML [665]processor should reject
   ill-formed streams and unidentified aliases. A YAML [666]processor may
   recover from syntax errors, possibly by ignoring certain parts of the
   input, but it must provide a mechanism for reporting such errors.

3.3.2. Resolved Tags

   Typically, most [667]tags are not explicitly specified in the character
   [668]stream. During [669]parsing, [670]nodes lacking an explicit
   [671]tag are given a non-specific tag: “!” for non-[672]plain scalars,
   and “?” for all other [673]nodes. [674]Composing a [675]complete
   representation requires each such non-specific tag to be resolved to a
   specific tag, be it a [676]global tag or a [677]local tag.

   Resolving the [678]tag of a [679]node must only depend on the following
   three parameters: (1) the non-specific tag of the [680]node, (2) the
   path leading from the [681]root to the [682]node, and (3) the
   [683]content (and hence the [684]kind) of the [685]node. When a
   [686]node has more than one occurrence (using [687]aliases), tag
   resolution must depend only on the path to the first ([688]anchored)
   occurrence of the [689]node.

   Note that resolution must not consider [690]presentation details such
   as [691]comments, [692]indentation and [693]node style. Also,
   resolution must not consider the [694]content of any other [695]node,
   except for the [696]content of the [697]key nodes directly along the
   path leading from the [698]root to the resolved [699]node. Finally,
   resolution must not consider the [700]content of a sibling [701]node in
   a [702]collection, or the [703]content of the [704]value node
   associated with a [705]key node being resolved.

   These rules ensure that tag resolution can be performed as soon as a
   [706]node is first encountered in the [707]stream, typically before its
   [708]content is [709]parsed. Also, tag resolution only requires
   referring to a relatively small number of previously parsed [710]nodes.
   Thus, in most cases, tag resolution in one-pass [711]processors is both
   possible and practical.

   YAML [712]processors should resolve [713]nodes having the “!”
   non-specific tag as “tag:yaml.org,2002:seq”, “tag:yaml.org,2002:map” or
   “tag:yaml.org,2002:str” depending on their [714]kind. This tag
   resolution convention allows the author of a YAML character [715]stream
   to effectively “disable” the tag resolution process. By explicitly
   specifying a “!” non-specific [716]tag property, the [717]node would
   then be resolved to a “vanilla” [718]sequence, [719]mapping, or string,
   according to its [720]kind.

   [721]Application specific tag resolution rules should be restricted to
   resolving the “?” non-specific tag, most commonly to resolving
   [722]plain scalars. These may be matched against a set of regular
   expressions to provide automatic resolution of integers, floats,
   timestamps, and similar types. An [723]application may also match the
   [724]content of [725]mapping nodes against sets of expected [726]keys
   to automatically resolve points, complex numbers, and similar types.
   Resolved [727]sequence node types such as the “ordered mapping” are
   also possible.

   That said, tag resolution is specific to the [728]application. YAML
   [729]processors should therefore provide a mechanism allowing the
   [730]application to override and expand these default tag resolution
   rules.

   If a [731]document contains unresolved tags, the YAML [732]processor is
   unable to [733]compose a [734]complete representation graph. In such a
   case, the YAML [735]processor may [736]compose a [737]partial
   representation, based on each [738]node’s kind and allowing for
   non-specific tags.

3.3.3. Recognized and Valid Tags

   To be valid, a [739]node must have a [740]tag which is recognized by
   the YAML [741]processor and its [742]content must satisfy the
   constraints imposed by this [743]tag. If a [744]document contains a
   [745]scalar node with an unrecognized tag or invalid content, only a
   [746]partial representation may be [747]composed. In contrast, a YAML
   [748]processor can always [749]compose a [750]complete representation
   for an unrecognized or an invalid [751]collection, since
   [752]collection [753]equality does not depend upon knowledge of the
   [754]collection’s data type. However, such a [755]complete
   representation cannot be used to [756]construct a [757]native data
   structure.

3.3.4. Available Tags

   In a given processing environment, there need not be an available
   native type corresponding to a given [758]tag. If a [759]node’s tag is
   unavailable, a YAML [760]processor will not be able to [761]construct a
   [762]native data structure for it. In this case, a [763]complete
   representation may still be [764]composed, and an [765]application may
   wish to use this [766]representation directly.

Chapter 4. Syntax Conventions

   The following chapters formally define the syntax of YAML character
   [767]streams, using parameterized BNF productions. Each BNF production
   is both named and numbered for easy reference. Whenever possible, basic
   structures are specified before the more complex structures using them
   in a “bottom up” fashion.

   The order of alternatives inside a production is significant.
   Subsequent alternatives are only considered when previous ones fails.
   See for example the [768]b-break production. In addition, production
   matching is expected to be greedy. Optional (?), zero-or-more (*) and
   one-or-more (+) patterns are always expected to match as much of the
   input as possible.

   The productions are accompanied by examples, which are given
   side-by-side next to equivalent YAML text in an explanatory format.
   This format uses only [769]flow collections, [770]double-quoted
   scalars, and explicit [771]tags for each [772]node.

   A reference implementation using the productions is available as the
   [773]YamlReference Haskell package. This reference implementation is
   also available as an interactive web application at
   [774]http://dev.yaml.org/ypaste.

4.1. Production Parameters

   YAML’s syntax is designed for maximal human readability. This requires
   [775]parsing to depend on the surrounding text. For notational
   compactness, this dependency is expressed using parameterized BNF
   productions.

   This context sensitivity is the cause of most of the complexity of the
   YAML syntax definition. It is further complicated by struggling with
   the human tendency to look ahead when interpreting text. These
   complications are of course the source of most of YAML’s power to
   [776]present data in a very human readable way.

   Productions use any of the following parameters:

   Indentation: n or m
          Many productions use an explicit [777]indentation level
          parameter. This is less elegant than Python’s “indent” and
          “undent” conceptual tokens. However it is required to formally
          express YAML’s indentation rules.

   Context: c
          This parameter allows productions to tweak their behavior
          according to their surrounding. YAML supports two groups of
          contexts, distinguishing between [778]block styles and [779]flow
          styles.

          In [780]block styles, [781]indentation is used to delineate
          structure. To capture human perception of [782]indentation the
          rules require special treatment of the [783]“-” character, used
          in [784]block sequences. Hence in some cases productions need to
          behave differently inside [785]block sequences (block-in
          context) and outside them (block-out context).

          In [786]flow styles, explicit [787]indicators are used to
          delineate structure. These styles can be viewed as the natural
          extension of JSON to cover [788]tagged, [789]single-quoted and
          [790]plain scalars. Since the latter have no delineating
          [791]indicators, they are subject to some restrictions to avoid
          ambiguities. These restrictions depend on where they appear: as
          implicit keys directly inside a [792]block mapping (block-key);
          as implicit keys inside a [793]flow mapping (flow-key); as
          values inside a [794]flow collection (flow-in); or as values
          outside one (flow-out).

   (Block) Chomping: t
          Block scalars offer three possible mechanisms for [795]chomping
          any trailing [796]line breaks: [797]strip, [798]clip and
          [799]keep. Unlike the previous parameters, this only controls
          interpretation; the [800]line breaks are valid in all cases.

4.2. Production Naming Conventions

   To make it easier to follow production combinations, production names
   use a Hungarian-style naming convention. Each production is given a
   prefix based on the type of characters it begins and ends with.

   e-
          A production matching no characters.

   c-
          A production starting and ending with a special character.

   b-
          A production matching a single [801]line break.

   nb-
          A production starting and ending with a non-[802]break
          character.

   s-
          A production starting and ending with a [803]white space
          character.

   ns-
          A production starting and ending with a non-[804]space
          character.

   l-
          A production matching complete line(s).

   X-Y-
          A production starting with an X- character and ending with a Y-
          character, where X- and Y- are any of the above prefixes.

   X+, X-Y+
          A production as above, with the additional property that the
          matched content [805]indentation level is greater than the
          specified n parameter.

Chapter 5. Characters

5.1. Character Set

   To ensure readability, YAML [806]streams use only the printable subset
   of the Unicode character set. The allowed character range explicitly
   excludes the C0 control block #x0-#x1F (except for TAB #x9, LF #xA, and
   CR #xD which are allowed), DEL #x7F, the C1 control block #x80-#x9F
   (except for NEL #x85 which is allowed), the surrogate block
   #xD800-#xDFFF, #xFFFE, and #xFFFF.

   On input, a YAML [807]processor must accept all Unicode characters
   except those explicitly excluded above.

   On output, a YAML [808]processor must only produce acceptable
   characters. Any excluded characters must be [809]presented using
   [810]escape sequences. In addition, any allowed characters known to be
   non-printable should also be [811]escaped. This isn’t mandatory since a
   full implementation would require extensive character property tables.
   [1] c-printable ::=   #x9 | #xA | #xD | [#x20-#x7E]          /* 8 bit
   */
   | #x85 | [#xA0-#xD7FF] | [#xE000-#xFFFD] /* 16 bit */
   | [#x10000-#x10FFFF]                     /* 32 bit */

   To ensure [812]JSON compatibility, YAML [813]processors must allow all
   non-control characters inside [814]quoted scalars. To ensure
   readability, non-printable characters should be [815]escaped on output,
   even inside such [816]scalars. Note that JSON [817]quoted scalars
   cannot span multiple lines or contain [818]tabs, but YAML [819]quoted
   scalars can.
   [2] nb-json ::= #x9 | [#x20-#x10FFFF]

5.2. Character Encodings

   All characters mentioned in this specification are Unicode code points.
   Each such code point is written as one or more bytes depending on the
   character encoding used. Note that in UTF-16, characters above #xFFFF
   are written as four bytes, using a surrogate pair.

   The character encoding is a [820]presentation detail and must not be
   used to convey [821]content information.

   On input, a YAML [822]processor must support the UTF-8 and UTF-16
   character encodings. For [823]JSON compatibility, the UTF-32 encodings
   must also be supported.

   If a character [824]stream begins with a byte order mark, the character
   encoding will be taken to be as as indicated by the byte order mark.
   Otherwise, the [825]stream must begin with an ASCII character. This
   allows the encoding to be deduced by the pattern of null (#x00)
   characters.

   To make it easier to concatenate [826]streams, byte order marks may
   appear at the start of any [827]document. However all [828]documents in
   the same [829]stream must use the same character encoding.

   To allow for [830]JSON compatibility, byte order marks are also allowed
   inside [831]quoted scalars. For readability, such [832]content byte
   order marks should be [833]escaped on output.

   The encoding can therefore be deduced by matching the first few bytes
   of the [834]stream with the following table rows (in order):
                            Byte0   Byte1   Byte2   Byte3   Encoding
     Explicit BOM           #x00    #x00    #xFE    #xFF    UTF-32BE
     ASCII first character  #x00    #x00    #x00    any     UTF-32BE
     Explicit BOM           #xFF    #xFE    #x00    #x00    UTF-32LE
     ASCII first character  any     #x00    #x00    #x00    UTF-32LE
     Explicit BOM           #xFE    #xFF                    UTF-16BE
     ASCII first character  #x00    any                     UTF-16BE
     Explicit BOM           #xFF    #xFE                    UTF-16LE
     ASCII first character  any     #x00                    UTF-16LE
     Explicit BOM           #xEF    #xBB    #xBF            UTF-8
     Default                                                UTF-8

   The recommended output encoding is UTF-8. If another encoding is used,
   it is recommended that an explicit byte order mark be used, even if the
   first [835]stream character is ASCII.

   For more information about the byte order mark and the Unicode
   character encoding schemes see the [836]Unicode FAQ.
   [3] c-byte-order-mark ::= #xFEFF

   In the examples, byte order mark characters are displayed as “⇔”.

   Example 5.1. Byte Order Mark
⇔# Comment only.

Legend:
  [837]c-byte-order-mark

# This stream contains no
# documents, only comments.

   Example 5.2. Invalid Byte Order Mark
- Invalid use of BOM
⇔
- Inside a document.

ERROR:
 A BOM must not appear
 inside a document.

5.3. Indicator Characters

   Indicators are characters that have special semantics.
   [4] c-sequence-entry ::= “-”
   A [838]“-” (#x2D, hyphen) denotes a [839]block sequence entry.
   [5] c-mapping-key ::= “?”
   A [840]“?” (#x3F, question mark) denotes a [841]mapping key.
   [6] c-mapping-value ::= “:”
   A [842]“:” (#x3A, colon) denotes a [843]mapping value.

   Example 5.3. Block Structure Indicators
sequence:
- one
- two
mapping:
  ? sky
  : blue
  sea : green

Legend:
  [844]c-sequence-entry
  [845]c-mapping-key [846]c-mapping-value

%YAML 1.2
---
!!map {
  ? !!str "sequence"
  : !!seq [ !!str "one", !!str "two" ],
  ? !!str "mapping"
  : !!map {
    ? !!str "sky" : !!str "blue",
    ? !!str "sea" : !!str "green",
  },
}

   [7] c-collect-entry ::= “,”
   A [847]“,” (#x2C, comma) ends a [848]flow collection entry.
   [8] c-sequence-start ::= “[”
   A [849]“[” (#x5B, left bracket) starts a [850]flow sequence.
   [9] c-sequence-end ::= “]”
   A [851]“]” (#x5D, right bracket) ends a [852]flow sequence.
   [10] c-mapping-start ::= “{”
   A [853]“{” (#x7B, left brace) starts a [854]flow mapping.
   [11] c-mapping-end ::= “}”
   A [855]“}” (#x7D, right brace) ends a [856]flow mapping.

   Example 5.4. Flow Collection Indicators
sequence: [ one, two, ]
mapping: { sky: blue, sea: green }

Legend:
  [857]c-sequence-start [858]c-sequence-end
  [859]c-mapping-start  [860]c-mapping-end
  [861]c-collect-entry

%YAML 1.2
---
!!map {
  ? !!str "sequence"
  : !!seq [ !!str "one", !!str "two" ],
  ? !!str "mapping"
  : !!map {
    ? !!str "sky" : !!str "blue",
    ? !!str "sea" : !!str "green",
  },
}

   [12] c-comment ::= “#”
   An [862]“#” (#x23, octothorpe, hash, sharp, pound, number sign) denotes
   a [863]comment.

   Example 5.5. Comment Indicator
# Comment only.

Legend:
  [864]c-comment

# This stream contains no
# documents, only comments.

   [13] c-anchor ::= “&”
   An [865]“&” (#x26, ampersand) denotes a [866]node’s anchor property.
   [14] c-alias ::= “*”
   An [867]“*” (#x2A, asterisk) denotes an [868]alias node.
   [15] c-tag ::= “!”
   The [869]“!” (#x21, exclamation) is heavily overloaded for specifying
   [870]node tags. It is used to denote [871]tag handles used in [872]tag
   directives and [873]tag properties; to denote [874]local tags; and as
   the [875]non-specific tag for non-[876]plain scalars.

   Example 5.6. Node Property Indicators
anchored: !local &anchor value
alias: *anchor

Legend:
  [877]c-tag [878]c-anchor [879]c-alias

%YAML 1.2
---
!!map {
  ? !!str "anchored"
  : !local &A1 "value",
  ? !!str "alias"
  : *A1,
}

   [16] c-literal ::= “|”
   A [880]“|” (7C, vertical bar) denotes a [881]literal block scalar.
   [17] c-folded ::= “>”
   A [882]“>” (#x3E, greater than) denotes a [883]folded block scalar.

   Example 5.7. Block Scalar Indicators
literal: |
  some
  text
folded: >
  some
  text

Legend:
  [884]c-literal [885]c-folded

%YAML 1.2
---
!!map {
  ? !!str "literal"
  : !!str "some\ntext\n",
  ? !!str "folded"
  : !!str "some text\n",
}

   [18] c-single-quote ::= “'”
   An [886]“'” (#x27, apostrophe, single quote) surrounds a
   [887]single-quoted flow scalar.
   [19] c-double-quote ::= “"”
   A [888]“"” (#x22, double quote) surrounds a [889]double-quoted flow
   scalar.

   Example 5.8. Quoted Scalar Indicators
single: 'text'
double: "text"

Legend:
  [890]c-single-quote [891]c-double-quote

%YAML 1.2
---
!!map {
  ? !!str "single"
  : !!str "text",
  ? !!str "double"
  : !!str "text",
}

   [20] c-directive ::= “%”
   A [892]“%” (#x25, percent) denotes a [893]directive line.

   Example 5.9. Directive Indicator
%YAML 1.2
--- text

Legend:
  [894]c-directive

%YAML 1.2
---
!!str "text"

   [21] c-reserved ::= “@” | “`”
   The “@” (#x40, at) and “`” (#x60, grave accent) are reserved for future
   use.

   Example 5.10. Invalid use of Reserved Indicators
commercial-at: @text
grave-accent: `text

ERROR:
 Reserved indicators can't
 start a plain scalar.

   Any indicator character:
   [22] c-indicator ::=   [895]“-” | [896]“?” | [897]“:” | [898]“,” |
   [899]“[” | [900]“]” | [901]“{” | [902]“}”
   | [903]“#” | [904]“&” | [905]“*” | [906]“!” | [907]“|” | [908]“>” |
   [909]“'” | [910]“"”
   | [911]“%” | [912]“@” | “`”

   The [913]“[”, [914]“]”, [915]“{”, [916]“}” and [917]“,” indicators
   denote structure in [918]flow collections. They are therefore forbidden
   in some cases, to avoid ambiguity in several constructs. This is
   handled on a case-by-case basis by the relevant productions.
   [23] c-flow-indicator ::= [919]“,” | [920]“[” | [921]“]” | [922]“{” |
   [923]“}”

5.4. Line Break Characters

   YAML recognizes the following ASCII line break characters.
   [24]       b-line-feed ::= #xA    /* LF */
   [25] b-carriage-return ::= #xD    /* CR */
   [26]            b-char ::= [924]b-line-feed | [925]b-carriage-return

   All other characters, including the form feed (#x0C), are considered to
   be non-break characters. Note that these include the non-ASCII line
   breaks: next line (#x85), line separator (#x2028) and paragraph
   separator (#x2029).

   [926]YAML version 1.1 did support the above non-ASCII line break
   characters; however, JSON does not. Hence, to ensure [927]JSON
   compatibility, YAML treats them as non-break characters as of version
   1.2. In theory this would cause incompatibility with [928]version 1.1;
   in practice these characters were rarely (if ever) used. YAML 1.2
   [929]processors [930]parsing a [931]version 1.1 [932]document should
   therefore treat these line breaks as non-break characters, with an
   appropriate warning.
   [27] nb-char ::= [933]c-printable - [934]b-char -
   [935]c-byte-order-mark

   Line breaks are interpreted differently by different systems, and have
   several widely used formats.
   [28] b-break ::=   ( [936]b-carriage-return [937]b-line-feed ) /* DOS,
   Windows */
   | [938]b-carriage-return                 /* MacOS upto 9.x */
   | [939]b-line-feed                       /* UNIX, MacOS X */

   Line breaks inside [940]scalar content must be normalized by the YAML
   [941]processor. Each such line break must be [942]parsed into a single
   line feed character. The original line break format is a
   [943]presentation detail and must not be used to convey [944]content
   information.
   [29] b-as-line-feed ::= [945]b-break

   Outside [946]scalar content, YAML allows any line break to be used to
   terminate lines.
   [30] b-non-content ::= [947]b-break

   On output, a YAML [948]processor is free to emit line breaks using
   whatever convention is most appropriate.

   In the examples, line breaks are sometimes displayed using the “↓”
   glyph for clarity.

   Example 5.11. Line Break Characters
|
  Line break (no glyph)
  Line break (glyphed)↓

Legend:
  [949]b-break

%YAML 1.2
---
!!str "line break (no glyph)\n\
      line break (glyphed)\n"

5.5. White Space Characters

   YAML recognizes two white space characters: space and tab.
   [31] s-space ::= #x20 /* SP */
   [32]   s-tab ::= #x9  /* TAB */
   [33] s-white ::= [950]s-space | [951]s-tab

   The rest of the ([952]printable) non-[953]break characters are
   considered to be non-space characters.
   [34] ns-char ::= [954]nb-char - [955]s-white

   In the examples, tab characters are displayed as the glyph “→”. Space
   characters are sometimes displayed as the glyph “·” for clarity.

   Example 5.12. Tabs and Spaces
# Tabs and spaces
quoted:·"Quoted →"
block:→|
··void main() {
··→printf("Hello, world!\n");
··}

Legend:
  [956]s-space [957]s-tab

%YAML 1.2
---
!!map {
  ? !!str "quoted"
  : "Quoted \t",
  ? !!str "block"
  : "void main() {\n\
    \tprintf(\"Hello, world!\\n\");\n\
    }\n",
}

5.6. Miscellaneous Characters

   The YAML syntax productions make use of the following additional
   character classes:
     * A decimal digit for numbers:

   [35] ns-dec-digit ::= [#x30-#x39] /* 0-9 */
     * A hexadecimal digit for [958]escape sequences:

   [36] ns-hex-digit ::=   [959]ns-dec-digit
   | [#x41-#x46] /* A-F */ | [#x61-#x66] /* a-f */
     * ASCII letter (alphabetic) characters:

   [37] ns-ascii-letter ::= [#x41-#x5A] /* A-Z */ | [#x61-#x7A] /* a-z */

     * Word (alphanumeric) characters for identifiers:

   [38] ns-word-char ::= [960]ns-dec-digit | [961]ns-ascii-letter | “-”
     * URI characters for [962]tags, as specified in [963]RFC2396, with
       the addition of the “[” and “]” for presenting IPv6 addresses as
       proposed in [964]RFC2732.
       By convention, any URI characters other than the allowed printable
       ASCII characters are first encoded in UTF-8, and then each byte is
       escaped using the “%” character. The YAML [965]processor must not
       expand such escaped characters. [966]Tag characters must be
       preserved and compared exactly as [967]presented in the YAML
       [968]stream, without any processing.

   [39] ns-uri-char ::=   “%” [969]ns-hex-digit [970]ns-hex-digit |
   [971]ns-word-char | “#”
   | “;” | “/” | “?” | “:” | “@” | “&” | “=” | “+” | “$” | “,”
   | “_” | “.” | “!” | “~” | “*” | “'” | “(” | “)” | “[” | “]”
     * The [972]“!” character is used to indicate the end of a [973]named
       tag handle; hence its use in [974]tag shorthands is restricted. In
       addition, such [975]shorthands must not contain the [976]“[”,
       [977]“]”, [978]“{”, [979]“}” and [980]“,” characters. These
       characters would cause ambiguity with [981]flow collection
       structures.

   [40] ns-tag-char ::= [982]ns-uri-char - [983]“!” -
   [984]c-flow-indicator

5.7. Escaped Characters

   All non-[985]printable characters must be escaped. YAML escape
   sequences use the “\” notation common to most modern computer
   languages. Each escape sequence must be [986]parsed into the
   appropriate Unicode character. The original escape sequence is a
   [987]presentation detail and must not be used to convey [988]content
   information.

   Note that escape sequences are only interpreted in [989]double-quoted
   scalars. In all other [990]scalar styles, the “\” character has no
   special meaning and non-[991]printable characters are not available.
   [41] c-escape ::= “\”

   YAML escape sequences are a superset of C’s escape sequences:
   [42] ns-esc-null ::= “0”
   Escaped ASCII null (#x0) character.
   [43] ns-esc-bell ::= “a”
   Escaped ASCII bell (#x7) character.
   [44] ns-esc-backspace ::= “b”
   Escaped ASCII backspace (#x8) character.
   [45] ns-esc-horizontal-tab ::= “t” | #x9
   Escaped ASCII horizontal tab (#x9) character. This is useful at the
   start or the end of a line to force a leading or trailing tab to become
   part of the [992]content.
   [46] ns-esc-line-feed ::= “n”
   Escaped ASCII line feed (#xA) character.
   [47] ns-esc-vertical-tab ::= “v”
   Escaped ASCII vertical tab (#xB) character.
   [48] ns-esc-form-feed ::= “f”
   Escaped ASCII form feed (#xC) character.
   [49] ns-esc-carriage-return ::= “r”
   Escaped ASCII carriage return (#xD) character.
   [50] ns-esc-escape ::= “e”
   Escaped ASCII escape (#x1B) character.
   [51] ns-esc-space ::= #x20
   Escaped ASCII space (#x20) character. This is useful at the start or
   the end of a line to force a leading or trailing space to become part
   of the [993]content.
   [52] ns-esc-double-quote ::= [994]“"”
   Escaped ASCII double quote (#x22).
   [53] ns-esc-slash ::= “/”
   Escaped ASCII slash (#x2F), for [995]JSON compatibility.
   [54] ns-esc-backslash ::= [996]“\”
   Escaped ASCII back slash (#x5C).
   [55] ns-esc-next-line ::= “N”
   Escaped Unicode next line (#x85) character.
   [56] ns-esc-non-breaking-space ::= “_”
   Escaped Unicode non-breaking space (#xA0) character.
   [57] ns-esc-line-separator ::= “L”
   Escaped Unicode line separator (#x2028) character.
   [58] ns-esc-paragraph-separator ::= “P”
   Escaped Unicode paragraph separator (#x2029) character.
   [59] ns-esc-8-bit ::= “x”
   ( [997]ns-hex-digit × 2 )
   Escaped 8-bit Unicode character.
   [60] ns-esc-16-bit ::= “u”
   ( [998]ns-hex-digit × 4 )
   Escaped 16-bit Unicode character.
   [61] ns-esc-32-bit ::= “U”
   ( [999]ns-hex-digit × 8 )
   Escaped 32-bit Unicode character.

   Any escaped character:
   [62] c-ns-esc-char ::= [1000]“\”
   ( [1001]ns-esc-null | [1002]ns-esc-bell | [1003]ns-esc-backspace
   | [1004]ns-esc-horizontal-tab | [1005]ns-esc-line-feed
   | [1006]ns-esc-vertical-tab | [1007]ns-esc-form-feed
   | [1008]ns-esc-carriage-return | [1009]ns-esc-escape |
   [1010]ns-esc-space
   | [1011]ns-esc-double-quote | [1012]ns-esc-slash |
   [1013]ns-esc-backslash
   | [1014]ns-esc-next-line | [1015]ns-esc-non-breaking-space
   | [1016]ns-esc-line-separator | [1017]ns-esc-paragraph-separator
   | [1018]ns-esc-8-bit | [1019]ns-esc-16-bit | [1020]ns-esc-32-bit )

   Example 5.13. Escaped Characters
"Fun with \\
\" \a \b \e \f \↓
\n \r \t \v \0 \↓
\  \_ \N \L \P \↓
\x41 \u0041 \U00000041"

Legend:
  [1021]c-ns-esc-char

%YAML 1.2
---
"Fun with \x5C
\x22 \x07 \x08 \x1B \x0C
\x0A \x0D \x09 \x0B \x00
\x20 \xA0 \x85 \u2028 \u2029
A A A"

   Example 5.14. Invalid Escaped Characters
Bad escapes:
  "\c
  \xq-"

ERROR:
- c is an invalid escaped character.
- q and - are invalid hex digits.

Chapter 6. Basic Structures

6.1. Indentation Spaces

   In YAML [1022]block styles, structure is determined by indentation. In
   general, indentation is defined as a zero or more [1023]space
   characters at the start of a line.

   To maintain portability, [1024]tab characters must not be used in
   indentation, since different systems treat [1025]tabs differently. Note
   that most modern editors may be configured so that pressing the
   [1026]tab key results in the insertion of an appropriate number of
   [1027]spaces.

   The amount of indentation is a [1028]presentation detail and must not
   be used to convey [1029]content information.
   [63] s-indent(n) ::= [1030]s-space × n

   A [1031]block style construct is terminated when encountering a line
   which is less indented than the construct. The productions use the
   notation “s-indent(<n)” and “s-indent(≤n)” to express this.
   [64] s-indent(<n) ::= [1032]s-space × m /* Where m < n */
   [65] s-indent(≤n) ::= [1033]s-space × m /* Where m ≤ n */

   Each [1034]node must be indented further than its parent [1035]node.
   All sibling [1036]nodes must use the exact same indentation level.
   However the [1037]content of each sibling [1038]node may be further
   indented independently.

   Example 6.1. Indentation Spaces
··# Leading comment line spaces are
···# neither content nor indentation.
····
Not indented:
·By one space: |
····By four
······spaces
·Flow style: [    # Leading spaces
···By two,        # in flow style
··Also by two,    # are neither
··→Still by two   # content nor
····]             # indentation.

Legend:
  [1039]s-indent(n) Content
  Neither content nor indentation

%YAML 1.2
- - -
!!map {
  ? !!str "Not indented"
  : !!map {
      ? !!str "By one space"
      : !!str "By four\n  spaces\n",
      ? !!str "Flow style"
      : !!seq [
          !!str "By two",
          !!str "Also by two",
          !!str "Still by two",
        ]
    }
}

   The [1040]“-”, [1041]“?” and [1042]“:” characters used to denote
   [1043]block collection entries are perceived by people to be part of
   the indentation. This is handled on a case-by-case basis by the
   relevant productions.

   Example 6.2. Indentation Indicators
?·a
:·-→b
··-··-→c
·····-·d

Legend:
  Total Indentation
  [1044]s-indent(n) Indicator as indentation

%YAML 1.2
---
!!map {
  ? !!str "a"
  : !!seq [
    !!str "b",
    !!seq [ !!str "c", !!str "d" ]
  ],
}

6.2. Separation Spaces

   Outside [1045]indentation and [1046]scalar content, YAML uses
   [1047]white space characters for separation between tokens within a
   line. Note that such [1048]white space may safely include [1049]tab
   characters.

   Separation spaces are a [1050]presentation detail and must not be used
   to convey [1051]content information.
   [66] s-separate-in-line ::= [1052]s-white+ | /* Start of line */

   Example 6.3. Separation Spaces
-·foo:→·bar
- -·baz
  -→baz

Legend:
  [1053]s-separate-in-line

%YAML 1.2
---
!!seq [
  !!map {
    ? !!str "foo" : !!str "bar",
  },
  !!seq [ !!str "baz", !!str "baz" ],
]

6.3. Line Prefixes

   Inside [1054]scalar content, each line begins with a non-[1055]content
   line prefix. This prefix always includes the [1056]indentation. For
   [1057]flow scalar styles it additionally includes all leading
   [1058]white space, which may contain [1059]tab characters.

   Line prefixes are a [1060]presentation detail and must not be used to
   convey [1061]content information.
   [67] s-line-prefix(n,c) ::= c = block-out ⇒
   [1062]s-block-line-prefix(n)
   c = block-in  ⇒ [1063]s-block-line-prefix(n)
   c = flow-out  ⇒ [1064]s-flow-line-prefix(n)
   c = flow-in   ⇒ [1065]s-flow-line-prefix(n)
   [68] s-block-line-prefix(n) ::= [1066]s-indent(n)
   [69] s-flow-line-prefix(n) ::= [1067]s-indent(n)
   [1068]s-separate-in-line?

   Example 6.4. Line Prefixes
plain: text
··lines
quoted: "text
··→lines"
block: |
··text
···→lines

Legend:
  [1069]s-flow-line-prefix(n) [1070]s-block-line-prefix(n) [1071]s-indent(n)

%YAML 1.2
---
!!map {
  ? !!str "plain"
  : !!str "text lines",
  ? !!str "quoted"
  : !!str "text lines",
  ? !!str "block"
  : !!str "text\n·→lines\n",
}

6.4. Empty Lines

   An empty line line consists of the non-[1072]content [1073]prefix
   followed by a [1074]line break.
   [70] l-empty(n,c) ::= ( [1075]s-line-prefix(n,c) | [1076]s-indent(<n) )
   [1077]b-as-line-feed

   The semantics of empty lines depend on the [1078]scalar style they
   appear in. This is handled on a case-by-case basis by the relevant
   productions.

   Example 6.5. Empty Lines
Folding:
  "Empty line
···→
  as a line feed"
Chomping: |
  Clipped empty lines
·

Legend:
  [1079]l-empty(n,c)

%YAML 1.2
---
!!map {
  ? !!str "Folding"
  : !!str "Empty line\nas a line feed",
  ? !!str "Chomping"
  : !!str "Clipped empty lines\n",
}

6.5. Line Folding

   Line folding allows long lines to be broken for readability, while
   retaining the semantics of the original long line. If a [1080]line
   break is followed by an [1081]empty line, it is trimmed; the first
   [1082]line break is discarded and the rest are retained as
   [1083]content.
   [71] b-l-trimmed(n,c) ::= [1084]b-non-content [1085]l-empty(n,c)+

   Otherwise (the following line is not [1086]empty), the [1087]line break
   is converted to a single [1088]space (#x20).
   [72] b-as-space ::= [1089]b-break

   A folded non-[1090]empty line may end with either of the above
   [1091]line breaks.
   [73] b-l-folded(n,c) ::= [1092]b-l-trimmed(n,c) | [1093]b-as-space

   Example 6.6. Line Folding
>-
  trimmed↓
··↓
·↓
↓
  as↓
  space

%YAML 1.2
---
!!str "trimmed\n\n\nas space"

 Legend:
   [1094]b-l-trimmed(n,c)
   [1095]b-as-space

   The above rules are common to both the [1096]folded block style and the
   [1097]scalar flow styles. Folding does distinguish between these cases
   in the following way:

   Block Folding
          In the [1098]folded block style, the final [1099]line break and
          trailing [1100]empty lines are subject to [1101]chomping, and
          are never folded. In addition, folding does not apply to
          [1102]line breaks surrounding text lines that contain leading
          [1103]white space. Note that such a [1104]more-indented line may
          consist only of such leading [1105]white space.

          The combined effect of the block line folding rules is that each
          “paragraph” is interpreted as a line, [1106]empty lines are
          interpreted as a line feed, and the formatting of
          [1107]more-indented lines is preserved.

   Example 6.7. Block Folding
>
··foo·↓
·↓
··→·bar↓
↓
··baz↓

%YAML 1.2
--- !!str
"foo \n\n\t bar\n\nbaz\n"

 Legend:
   [1108]b-l-folded(n,c)
   Non-content spaces Content spaces

   Flow Folding
          Folding in [1109]flow styles provides more relaxed semantics.
          [1110]Flow styles typically depend on explicit [1111]indicators
          rather than [1112]indentation to convey structure. Hence spaces
          preceding or following the text in a line are a
          [1113]presentation detail and must not be used to convey
          [1114]content information. Once all such spaces have been
          discarded, all [1115]line breaks are folded, without exception.

          The combined effect of the flow line folding rules is that each
          “paragraph” is interpreted as a line, [1116]empty lines are
          interpreted as line feeds, and text can be freely
          [1117]more-indented without affecting the [1118]content
          information.

   [74] s-flow-folded(n) ::= [1119]s-separate-in-line?
   [1120]b-l-folded(n,flow-in)
   [1121]s-flow-line-prefix(n)

   Example 6.8. Flow Folding
"↓
··foo·↓
·↓
··→·bar↓
↓
··baz↓
"

%YAML 1.2
--- !!str
" foo\nbar\nbaz "

 Legend:
   [1122]s-flow-folded(n)
   Non-content spaces

6.6. Comments

   An explicit comment is marked by a “#” indicator. Comments are a
   [1123]presentation detail and must not be used to convey [1124]content
   information.

   Comments must be [1125]separated from other tokens by [1126]white space
   characters. To ensure [1127]JSON compatibility, YAML [1128]processors
   must allow for the omission of the final comment [1129]line break of
   the input [1130]stream. However, as this confuses many tools, YAML
   [1131]processors should terminate the [1132]stream with an explicit
   [1133]line break on output.
   [75] c-nb-comment-text ::= [1134]“#” [1135]nb-char*
   [76] b-comment ::= [1136]b-non-content | /* End of file */
   [77] s-b-comment ::= ( [1137]s-separate-in-line
   [1138]c-nb-comment-text? )?
   [1139]b-comment

   Example 6.9. Separated Comment
key:····# Comment↓
  valueeof

Legend:
  [1140]c-nb-comment-text [1141]b-comment
  [1142]s-b-comment

%YAML 1.2
---
!!map {
  ? !!str "key"
  : !!str "value",
}

   Outside [1143]scalar content, comments may appear on a line of their
   own, independent of the [1144]indentation level. Note that outside
   [1145]scalar content, a line containing only [1146]white space
   characters is taken to be a comment line.
   [78] l-comment ::= [1147]s-separate-in-line [1148]c-nb-comment-text?
   [1149]b-comment

   Example 6.10. Comment Lines
··# Comment↓
···↓
↓

# This stream contains no
# documents, only comments.

 Legend:
   [1150]s-b-comment [1151]l-comment

   In most cases, when a line may end with a comment, YAML allows it to be
   followed by additional comment lines. The only exception is a comment
   ending a [1152]block scalar header.
   [79] s-l-comments ::= ( [1153]s-b-comment | /* Start of line */ )
   [1154]l-comment*

   Example 6.11. Multi-Line Comments
key:····# Comment↓
········# lines↓
  value↓
↓

%YAML 1.2
---
!!map {
  ? !!str "key"
  : !!str "value",
}

Legend:
  [1155]s-b-comment [1156]l-comment [1157]s-l-comments

6.7. Separation Lines

   [1158]Implicit keys are restricted to a single line. In all other
   cases, YAML allows tokens to be separated by multi-line (possibly
   empty) [1159]comments.

   Note that structures following multi-line comment separation must be
   properly [1160]indented, even though there is no such restriction on
   the separation [1161]comment lines themselves.
   [80] s-separate(n,c) ::= c = block-out ⇒ [1162]s-separate-lines(n)
   c = block-in  ⇒ [1163]s-separate-lines(n)
   c = flow-out  ⇒ [1164]s-separate-lines(n)
   c = flow-in   ⇒ [1165]s-separate-lines(n)
   c = block-key ⇒ [1166]s-separate-in-line
   c = flow-key  ⇒ [1167]s-separate-in-line
   [81] s-separate-lines(n) ::=   ( [1168]s-l-comments
   [1169]s-flow-line-prefix(n) )
   | [1170]s-separate-in-line

   Example 6.12. Separation Spaces
{·first:·Sammy,·last:·Sosa·}:↓
# Statistics:
··hr:··# Home runs
·····65
··avg:·# Average
···0.278

Legend:
  [1171]s-separate-in-line
  [1172]s-separate-lines(n)
  [1173]s-indent(n)

%YAML 1.2
---
!!map {
  ? !!map {
    ? !!str "first"
    : !!str "Sammy",
    ? !!str "last"
    : !!str "Sosa",
  }
  : !!map {
    ? !!str "hr"
    : !!int "65",
    ? !!str "avg"
    : !!float "0.278",
  },
}

6.8. Directives

   Directives are instructions to the YAML [1174]processor. This
   specification defines two directives, [1175]“YAML” and [1176]“TAG”, and
   reserves all other directives for future use. There is no way to define
   private directives. This is intentional.

   Directives are a [1177]presentation detail and must not be used to
   convey [1178]content information.
   [82] l-directive ::= [1179]“%”
   ( [1180]ns-yaml-directive
   | [1181]ns-tag-directive
   | [1182]ns-reserved-directive )
   [1183]s-l-comments

   Each directive is specified on a separate non-[1184]indented line
   starting with the “%” indicator, followed by the directive name and a
   list of parameters. The semantics of these parameters depends on the
   specific directive. A YAML [1185]processor should ignore unknown
   directives with an appropriate warning.
   [83] ns-reserved-directive ::= [1186]ns-directive-name
   ( [1187]s-separate-in-line [1188]ns-directive-parameter )*
   [84] ns-directive-name ::= [1189]ns-char+
   [85] ns-directive-parameter ::= [1190]ns-char+

   Example 6.13. Reserved Directives
%FOO  bar baz # Should be ignored
               # with a warning.
--- "foo"

%YAML 1.2
--- !!str
"foo"

Legend:
  [1191]ns-reserved-directive [1192]ns-directive-name [1193]ns-directive-paramet
er

6.8.1. “YAML” Directives

   The “YAML” directive specifies the version of YAML the [1194]document
   conforms to. This specification defines version “1.2”, including
   recommendations for YAML 1.1 processing.

   A version 1.2 YAML [1195]processor must accept [1196]documents with an
   explicit “%YAML 1.2” directive, as well as [1197]documents lacking a
   “YAML” directive. Such [1198]documents are assumed to conform to the
   1.2 version specification. [1199]Documents with a “YAML” directive
   specifying a higher minor version (e.g. “%YAML 1.3”) should be
   processed with an appropriate warning. [1200]Documents with a “YAML”
   directive specifying a higher major version (e.g. “%YAML 2.0”) should
   be rejected with an appropriate error message.

   A version 1.2 YAML [1201]processor must also accept [1202]documents
   with an explicit “%YAML 1.1” directive. Note that version 1.2 is mostly
   a superset of version 1.1, defined for the purpose of ensuring JSON
   compatibility. Hence a version 1.2 [1203]processor should process
   version 1.1 [1204]documents as if they were version 1.2, giving a
   warning on points of incompatibility (handling of [1205]non-ASCII line
   breaks, as described [1206]above).
   [86] ns-yaml-directive ::= “Y” “A” “M” “L”
   [1207]s-separate-in-line [1208]ns-yaml-version
   [87] ns-yaml-version ::= [1209]ns-dec-digit+ “.” [1210]ns-dec-digit+

   Example 6.14. “YAML” directive
%YAML 1.3 # Attempt parsing
           # with a warning
---
"foo"

%YAML 1.2
---
!!str "foo"

 Legend:
   [1211]ns-yaml-directive [1212]ns-yaml-version

   It is an error to specify more than one “YAML” directive for the same
   document, even if both occurrences give the same version number.

   Example 6.15. Invalid Repeated YAML directive
%YAML 1.2
%YAML 1.1
foo

ERROR:
The YAML directive must only be
given at most once per document.

6.8.2. “TAG” Directives

   The “TAG” directive establishes a [1213]tag shorthand notation for
   specifying [1214]node tags. Each “TAG” directive associates a
   [1215]handle with a [1216]prefix. This allows for compact and readable
   [1217]tag notation.
   [88] ns-tag-directive ::= “T” “A” “G”
   [1218]s-separate-in-line [1219]c-tag-handle
   [1220]s-separate-in-line [1221]ns-tag-prefix

   Example 6.16. “TAG” directive
%TAG !yaml! tag:yaml.org,2002:
---
!yaml!str "foo"

%YAML 1.2
---
!!str "foo"

Legend:
  [1222]ns-tag-directive [1223]c-tag-handle [1224]ns-tag-prefix

   It is an error to specify more than one “TAG” directive for the same
   [1225]handle in the same document, even if both occurrences give the
   same [1226]prefix.

   Example 6.17. Invalid Repeated TAG directive
%TAG ! !foo
%TAG ! !foo
bar

ERROR:
The TAG directive must only
be given at most once per
handle in the same document.

6.8.2.1. Tag Handles

   The tag handle exactly matches the prefix of the affected [1227]tag
   shorthand. There are three tag handle variants:
   [89] c-tag-handle ::=   [1228]c-named-tag-handle
   | [1229]c-secondary-tag-handle
   | [1230]c-primary-tag-handle

   Primary Handle
          The primary tag handle is a single “!” character. This allows
          using the most compact possible notation for a single “primary”
          name space. By default, the prefix associated with this handle
          is [1231]“!”. Thus, by default, [1232]shorthands using this
          handle are interpreted as [1233]local tags.

          It is possible to override the default behavior by providing an
          explicit “TAG” directive, associating a different prefix for
          this handle. This provides smooth migration from using
          [1234]local tags to using [1235]global tags, by the simple
          addition of a single “TAG” directive.

   [90] c-primary-tag-handle ::= [1236]“!”

   Example 6.18. Primary Tag Handle
# Private
!foo "bar"
...
# Global
%TAG ! tag:example.com,2000:app/
---
!foo "bar"

%YAML 1.2
---
!<!foo> "bar"
...
---
!<tag:example.com,2000:app/foo> "bar"

Legend:
  [1237]c-primary-tag-handle

   Secondary Handle
          The secondary tag handle is written as “!!”. This allows using a
          compact notation for a single “secondary” name space. By
          default, the prefix associated with this handle is
          “tag:yaml.org,2002:”. This prefix is used by the [1238]YAML tag
          repository.

          It is possible to override this default behavior by providing an
          explicit “TAG” directive associating a different prefix for this
          handle.

   [91] c-secondary-tag-handle ::= [1239]“!” [1240]“!”

   Example 6.19. Secondary Tag Handle
%TAG !! tag:example.com,2000:app/
---
!!int 1 - 3 # Interval, not integer

Legend:
  [1241]c-secondary-tag-handle

%YAML 1.2
---
!<tag:example.com,2000:app/int> "1 - 3"

   Named Handles
          A named tag handle surrounds a non-empty name with “!”
          characters. A handle name must not be used in a [1242]tag
          shorthand unless an explicit “TAG” directive has associated some
          prefix with it.

          The name of the handle is a [1243]presentation detail and must
          not be used to convey [1244]content information. In particular,
          the YAML [1245]processor need not preserve the handle name once
          [1246]parsing is completed.

   [92] c-named-tag-handle ::= [1247]“!” [1248]ns-word-char+ [1249]“!”

   Example 6.20. Tag Handles
%TAG !e! tag:example.com,2000:app/
---
!e!foo "bar"

Legend:
  [1250]c-named-tag-handle

%YAML 1.2
---
!<tag:example.com,2000:app/foo> "bar"

6.8.2.2. Tag Prefixes

   There are two tag prefix variants:
   [93] ns-tag-prefix ::= [1251]c-ns-local-tag-prefix |
   [1252]ns-global-tag-prefix

   Local Tag Prefix
          If the prefix begins with a [1253]“!” character,
          [1254]shorthands using the [1255]handle are expanded to a
          [1256]local tag. Note that such a [1257]tag is intentionally not
          a valid URI, and its semantics are specific to the
          [1258]application. In particular, two [1259]documents in the
          same [1260]stream may assign different semantics to the same
          [1261]local tag.

   [94] c-ns-local-tag-prefix ::= [1262]“!” [1263]ns-uri-char*

   Example 6.21. Local Tag Prefix
%TAG !m! !my-
--- # Bulb here
!m!light fluorescent
...
%TAG !m! !my-
--- # Color here
!m!light green

Legend:
  [1264]c-ns-local-tag-prefix

%YAML 1.2
---
!<!my-light> "fluorescent"
...
%YAML 1.2
---
!<!my-light> "green"

   Global Tag Prefix
          If the prefix begins with a character other than [1265]“!”, it
          must to be a valid URI prefix, and should contain at least the
          scheme and the authority. [1266]Shorthands using the associated
          [1267]handle are expanded to globally unique URI tags, and their
          semantics is consistent across [1268]applications. In
          particular, every [1269]documents in every [1270]stream must
          assign the same semantics to the same [1271]global tag.

   [95] ns-global-tag-prefix ::= [1272]ns-tag-char [1273]ns-uri-char*

   Example 6.22. Global Tag Prefix
%TAG !e! tag:example.com,2000:app/
---
- !e!foo "bar"

Legend:
  [1274]ns-global-tag-prefix

%YAML 1.2
---
!<tag:example.com,2000:app/foo> "bar"

6.9. Node Properties

   Each [1275]node may have two optional properties, [1276]anchor and
   [1277]tag, in addition to its [1278]content. Node properties may be
   specified in any order before the [1279]node’s content. Either or both
   may be omitted.
   [96] c-ns-properties(n,c) ::=   ( [1280]c-ns-tag-property
       ( [1281]s-separate(n,c) [1282]c-ns-anchor-property )? )
   | ( [1283]c-ns-anchor-property
       ( [1284]s-separate(n,c) [1285]c-ns-tag-property )? )

   Example 6.23. Node Properties
!!str &a1 "foo":
  !!str bar
&a2 baz : *a1

Legend:
  [1286]c-ns-properties(n,c)
  [1287]c-ns-anchor-property
  [1288]c-ns-tag-property

%YAML 1.2
---
!!map {
  ? &B1 !!str "foo"
  : !!str "bar",
  ? !!str "baz"
  : *B1,
}

6.9.1. Node Tags

   The tag property identifies the type of the [1289]native data structure
   [1290]presented by the [1291]node. A tag is denoted by the “!”
   indicator.
   [97] c-ns-tag-property ::=   [1292]c-verbatim-tag
   | [1293]c-ns-shorthand-tag
   | [1294]c-non-specific-tag

   Verbatim Tags
          A tag may be written verbatim by surrounding it with the “<” and
          “>” characters. In this case, the YAML [1295]processor must
          deliver the verbatim tag as-is to the [1296]application. In
          particular, verbatim tags are not subject to [1297]tag
          resolution. A verbatim tag must either begin with a [1298]“!” (a
          [1299]local tag) or be a valid URI (a [1300]global tag).

   [98] c-verbatim-tag ::= [1301]“!” “<” [1302]ns-uri-char+ “>”

   Example 6.24. Verbatim Tags
!<tag:yaml.org,2002:str> foo :
  !<!bar> baz

Legend:
  [1303]c-verbatim-tag

%YAML 1.2
---
!!map {
  ? !<tag:yaml.org,2002:str> "foo"
  : !<!bar> "baz",
}

   Example 6.25. Invalid Verbatim Tags
- !<!> foo
- !<$:?> bar

ERROR:
- Verbatim tags aren't resolved,
  so ! is invalid.
- The $:? tag is neither a global
  URI tag nor a local tag starting
  with “!”.

   Tag Shorthands
          A tag shorthand consists of a valid [1304]tag handle followed by
          a non-empty suffix. The [1305]tag handle must be associated with
          a [1306]prefix, either by default or by using a [1307]“TAG”
          directive. The resulting [1308]parsed [1309]tag is the
          concatenation of the [1310]prefix and the suffix, and must
          either begin with [1311]“!” (a [1312]local tag) or be a valid
          URI (a [1313]global tag).

          The choice of [1314]tag handle is a [1315]presentation detail
          and must not be used to convey [1316]content information. In
          particular, the [1317]tag handle may be discarded once
          [1318]parsing is completed.

          The suffix must not contain any [1319]“!” character. This would
          cause the tag shorthand to be interpreted as having a
          [1320]named tag handle. In addition, the suffix must not contain
          the [1321]“[”, [1322]“]”, [1323]“{”, [1324]“}” and [1325]“,”
          characters. These characters would cause ambiguity with
          [1326]flow collection structures. If the suffix needs to specify
          any of the above restricted characters, they must be
          [1327]escaped using the [1328]“%” character. This behavior is
          consistent with the URI character escaping rules (specifically,
          section 2.3 of [1329]RFC2396).

   [99] c-ns-shorthand-tag ::= [1330]c-tag-handle [1331]ns-tag-char+

   Example 6.26. Tag Shorthands
%TAG !e! tag:example.com,2000:app/
---
- !local foo
- !!str bar
- !e!tag%21 baz

Legend:
  [1332]c-ns-shorthand-tag

%YAML 1.2
---
!!seq [
  !<!local> "foo",
  !<tag:yaml.org,2002:str> "bar",
  !<tag:example.com,2000:app/tag!> "baz"
]

   Example 6.27. Invalid Tag Shorthands
%TAG !e! tag:example,2000:app/
---
- !e! foo
- !h!bar baz

ERROR:
- The !o! handle has no suffix.
- The !h! handle wasn't declared.

   Non-Specific Tags
          If a [1333]node has no tag property, it is assigned a
          [1334]non-specific tag that needs to be [1335]resolved to a
          [1336]specific one. This [1337]non-specific tag is [1338]“!” for
          non-[1339]plain scalars and [1340]“?” for all other [1341]nodes.
          This is the only case where the [1342]node style has any effect
          on the [1343]content information.

          It is possible for the tag property to be explicitly set to the
          [1344]“!” non-specific tag. By [1345]convention, this “disables”
          [1346]tag resolution, forcing the [1347]node to be interpreted
          as “tag:yaml.org,2002:seq”, “tag:yaml.org,2002:map”, or
          “tag:yaml.org,2002:str”, according to its [1348]kind.

          There is no way to explicitly specify the [1349]“?” non-specific
          tag. This is intentional.

   [100] c-non-specific-tag ::= [1350]“!”

   Example 6.28. Non-Specific Tags
# Assuming conventional resolution:
- "12"
- 12
- ! 12

Legend:
  [1351]c-non-specific-tag

%YAML 1.2
---
!!seq [
  !<tag:yaml.org,2002:str> "12",
  !<tag:yaml.org,2002:int> "12",
  !<tag:yaml.org,2002:str> "12",
]

6.9.2. Node Anchors

   An anchor is denoted by the “&” indicator. It marks a [1352]node for
   future reference. An [1353]alias node can then be used to indicate
   additional inclusions of the anchored [1354]node. An anchored
   [1355]node need not be referenced by any [1356]alias nodes; in
   particular, it is valid for all [1357]nodes to be anchored.
   [101] c-ns-anchor-property ::= [1358]“&” [1359]ns-anchor-name

   Note that as a [1360]serialization detail, the anchor name is preserved
   in the [1361]serialization tree. However, it is not reflected in the
   [1362]representation graph and must not be used to convey [1363]content
   information. In particular, the YAML [1364]processor need not preserve
   the anchor name once the [1365]representation is [1366]composed.

   Anchor names must not contain the [1367]“[”, [1368]“]”, [1369]“{”,
   [1370]“}” and [1371]“,” characters. These characters would cause
   ambiguity with [1372]flow collection structures.
   [102] ns-anchor-char ::= [1373]ns-char - [1374]c-flow-indicator
   [103] ns-anchor-name ::= [1375]ns-anchor-char+

   Example 6.29. Node Anchors
First occurrence: &anchor Value
Second occurrence: *anchor

Legend:
  [1376]c-ns-anchor-property [1377]ns-anchor-name

%YAML 1.2
---
!!map {
  ? !!str "First occurrence"
  : &A !!str "Value",
  ? !!str "Second occurrence"
  : *A,
}

Chapter 7. Flow Styles

   YAML’s flow styles can be thought of as the natural extension of JSON
   to cover [1378]folding long content lines for readability,
   [1379]tagging nodes to control [1380]construction of [1381]native data
   structures, and using [1382]anchors and [1383]aliases to reuse
   [1384]constructed object instances.

7.1. Alias Nodes

   Subsequent occurrences of a previously [1385]serialized node are
   [1386]presented as alias nodes. The first occurrence of the [1387]node
   must be marked by an [1388]anchor to allow subsequent occurrences to be
   [1389]presented as alias nodes.

   An alias node is denoted by the “*” indicator. The alias refers to the
   most recent preceding [1390]node having the same [1391]anchor. It is an
   error for an alias node to use an [1392]anchor that does not previously
   occur in the [1393]document. It is not an error to specify an
   [1394]anchor that is not used by any alias node.

   Note that an alias node must not specify any [1395]properties or
   [1396]content, as these were already specified at the first occurrence
   of the [1397]node.
   [104] c-ns-alias-node ::= [1398]“*” [1399]ns-anchor-name

   Example 7.1. Alias Nodes
First occurrence: &anchor Foo
Second occurrence: *anchor
Override anchor: &anchor Bar
Reuse anchor: *anchor

Legend:
  [1400]c-ns-alias-node [1401]ns-anchor-name

%YAML 1.2
---
!!map {
  ? !!str "First occurrence"
  : &A !!str "Foo",
  ? !!str "Override anchor"
  : &B !!str "Bar",
  ? !!str "Second occurrence"
  : *A,
  ? !!str "Reuse anchor"
  : *B,
}

7.2. Empty Nodes

   YAML allows the [1402]node content to be omitted in many cases.
   [1403]Nodes with empty [1404]content are interpreted as if they were
   [1405]plain scalars with an empty value. Such [1406]nodes are commonly
   resolved to a [1407]“null” value.
   [105] e-scalar ::= /* Empty */

   In the examples, empty [1408]scalars are sometimes displayed as the
   glyph “°” for clarity. Note that this glyph corresponds to a position
   in the characters [1409]stream rather than to an actual character.

   Example 7.2. Empty Content
{
  foo : !!str°,
  !!str° : bar,
}

Legend:
  [1410]e-scalar

%YAML 1.2
---
!!map {
  ? !!str "foo" : !!str "",
  ? !!str ""    : !!str "bar",
}

   Both the [1411]node’s properties and [1412]node content are optional.
   This allows for a completely empty node. Completely empty nodes are
   only valid when following some explicit indication for their existence.
   [106] e-node ::= [1413]e-scalar

   Example 7.3. Completely Empty Flow Nodes
{
  ? foo :°,
  °: bar,
}

Legend:
  [1414]e-node

%YAML 1.2
---
!!map {
  ? !!str "foo" : !!null "",
  ? !!null ""   : !!str "bar",
}

7.3. Flow Scalar Styles

   YAML provides three flow scalar styles: [1415]double-quoted,
   [1416]single-quoted and [1417]plain (unquoted). Each provides a
   different trade-off between readability and expressive power.

   The [1418]scalar style is a [1419]presentation detail and must not be
   used to convey [1420]content information, with the exception that
   [1421]plain scalars are distinguished for the purpose of [1422]tag
   resolution.

7.3.1. Double-Quoted Style

   The double-quoted style is specified by surrounding “"” indicators.
   This is the only [1423]style capable of expressing arbitrary strings,
   by using [1424]“\” [1425]escape sequences. This comes at the cost of
   having to escape the [1426]“\” and “"” characters.
   [107] nb-double-char ::= [1427]c-ns-esc-char | ( [1428]nb-json -
   [1429]“\” - [1430]“"” )
   [108] ns-double-char ::= [1431]nb-double-char - [1432]s-white

   Double-quoted scalars are restricted to a single line when contained
   inside an [1433]implicit key.
   [109] c-double-quoted(n,c) ::= [1434]“"” [1435]nb-double-text(n,c)
   [1436]“"”
   [110] nb-double-text(n,c) ::= c = flow-out  ⇒
   [1437]nb-double-multi-line(n)
   c = flow-in   ⇒ [1438]nb-double-multi-line(n)
   c = block-key ⇒ [1439]nb-double-one-line
   c = flow-key  ⇒ [1440]nb-double-one-line
   [111] nb-double-one-line ::= [1441]nb-double-char*

   Example 7.4. Double Quoted Implicit Keys
"implicit block key" : [
  "implicit flow key" : value,
 ]

Legend:
  [1442]nb-double-one-line
  [1443]c-double-quoted(n,c)

%YAML 1.2
---
!!map {
  ? !!str "implicit block key"
  : !!seq [
    !!map {
      ? !!str "implicit flow key"
      : !!str "value",
    }
  ]
}

   In a multi-line double-quoted scalar, [1444]line breaks are are subject
   to [1445]flow line folding, which discards any trailing [1446]white
   space characters. It is also possible to escape the [1447]line break
   character. In this case, the [1448]line break is excluded from the
   [1449]content, and the trailing [1450]white space characters are
   preserved. Combined with the ability to [1451]escape [1452]white space
   characters, this allows double-quoted lines to be broken at arbitrary
   positions.
   [112] s-double-escaped(n) ::= [1453]s-white* [1454]“\”
   [1455]b-non-content
   [1456]l-empty(n,flow-in)* [1457]s-flow-line-prefix(n)
   [113] s-double-break(n) ::= [1458]s-double-escaped(n) |
   [1459]s-flow-folded(n)

   Example 7.5. Double Quoted Line Breaks
"folded·↓
to a space,→↓
·↓
to a line feed, or·→\↓
·\·→non-content"

%YAML 1.2
---
!!str "folded to a space,\n\
      to a line feed, \
      or \t \tnon-content"

Legend:
  [1460]s-flow-folded(n) [1461]s-double-escaped(n)

   All leading and trailing [1462]white space characters are excluded from
   the [1463]content. Each continuation line must therefore contain at
   least one non-[1464]space character. Empty lines, if any, are consumed
   as part of the [1465]line folding.
   [114] nb-ns-double-in-line ::= ( [1466]s-white* [1467]ns-double-char )*

   [115] s-double-next-line(n) ::= [1468]s-double-break(n)
   ( [1469]ns-double-char [1470]nb-ns-double-in-line
     ( [1471]s-double-next-line(n) | [1472]s-white* ) )?
   [116] nb-double-multi-line(n) ::= [1473]nb-ns-double-in-line
   ( [1474]s-double-next-line(n) | [1475]s-white* )

   Example 7.6. Double Quoted Lines
"·1st non-empty↓
↓
·2nd non-empty·
→3rd non-empty·"

%YAML 1.2
---
!!str " 1st non-empty\n\
      2nd non-empty \
      3rd non-empty "

Legend:
  [1476]nb-ns-double-in-line [1477]s-double-next-line(n)

7.3.2. Single-Quoted Style

   The single-quoted style is specified by surrounding “'” indicators.
   Therefore, within a single-quoted scalar, such characters need to be
   repeated. This is the only form of escaping performed in single-quoted
   scalars. In particular, the “\” and “"” characters may be freely used.
   This restricts single-quoted scalars to [1478]printable characters. In
   addition, it is only possible to break a long single-quoted line where
   a [1479]space character is surrounded by non-[1480]spaces.
   [117] c-quoted-quote ::= [1481]“'” [1482]“'”
   [118] nb-single-char ::= [1483]c-quoted-quote | ( [1484]nb-json -
   [1485]“'” )
   [119] ns-single-char ::= [1486]nb-single-char - [1487]s-white

   Example 7.7. Single Quoted Characters
 'here''s to "quotes"'

Legend:
  [1488]c-quoted-quote

%YAML 1.2
---
!!str "here's to \"quotes\""

   Single-quoted scalars are restricted to a single line when contained
   inside a [1489]implicit key.
   [120] c-single-quoted(n,c) ::= [1490]“'” [1491]nb-single-text(n,c)
   [1492]“'”
   [121] nb-single-text(n,c) ::= c = flow-out  ⇒
   [1493]nb-single-multi-line(n)
   c = flow-in   ⇒ [1494]nb-single-multi-line(n)
   c = block-key ⇒ [1495]nb-single-one-line
   c = flow-key  ⇒ [1496]nb-single-one-line
   [122] nb-single-one-line ::= [1497]nb-single-char*

   Example 7.8. Single Quoted Implicit Keys
'implicit block key' : [
  'implicit flow key' : value,
 ]

Legend:
  [1498]nb-single-one-line
  [1499]c-single-quoted(n,c)

%YAML 1.2
---
!!map {
  ? !!str "implicit block key"
  : !!seq [
    !!map {
      ? !!str "implicit flow key"
      : !!str "value",
    }
  ]
}

   All leading and trailing [1500]white space characters are excluded from
   the [1501]content. Each continuation line must therefore contain at
   least one non-[1502]space character. Empty lines, if any, are consumed
   as part of the [1503]line folding.
   [123] nb-ns-single-in-line ::= ( [1504]s-white* [1505]ns-single-char )*

   [124] s-single-next-line(n) ::= [1506]s-flow-folded(n)
   ( [1507]ns-single-char [1508]nb-ns-single-in-line
     ( [1509]s-single-next-line(n) | [1510]s-white* ) )?
   [125] nb-single-multi-line(n) ::= [1511]nb-ns-single-in-line
   ( [1512]s-single-next-line(n) | [1513]s-white* )

   Example 7.9. Single Quoted Lines
'·1st non-empty↓
↓
·2nd non-empty·
→3rd non-empty·'

%YAML 1.2
---
!!str " 1st non-empty\n\
      2nd non-empty \
      3rd non-empty "

Legend:
  [1514]nb-ns-single-in-line(n) [1515]s-single-next-line(n)

7.3.3. Plain Style

   The plain (unquoted) style has no identifying [1516]indicators and
   provides no form of escaping. It is therefore the most readable, most
   limited and most [1517]context sensitive [1518]style. In addition to a
   restricted character set, a plain scalar must not be empty, or contain
   leading or trailing [1519]white space characters. It is only possible
   to break a long plain line where a [1520]space character is surrounded
   by non-[1521]spaces.

   Plain scalars must not begin with most [1522]indicators, as this would
   cause ambiguity with other YAML constructs. However, the [1523]“:”,
   [1524]“?” and [1525]“-” [1526]indicators may be used as the first
   character if followed by a non-[1527]space “safe” character, as this
   causes no ambiguity.
   [126] ns-plain-first(c) ::=   ( [1528]ns-char - [1529]c-indicator )
   | ( ( [1530]“?” | [1531]“:” | [1532]“-” )
       /* Followed by an [1533]ns-plain-safe(c)) */ )

   Plain scalars must never contain the [1534]“: ” and [1535]“ #”
   character combinations. Such combinations would cause ambiguity with
   [1536]mapping [1537]key: value pairs and [1538]comments. In addition,
   inside [1539]flow collections, or when used as [1540]implicit keys,
   plain scalars must not contain the [1541]“[”, [1542]“]”, [1543]“{”,
   [1544]“}” and [1545]“,” characters. These characters would cause
   ambiguity with [1546]flow collection structures.
   [127] ns-plain-safe(c) ::= c = flow-out  ⇒ [1547]ns-plain-safe-out
   c = flow-in   ⇒ [1548]ns-plain-safe-in
   c = block-key ⇒ [1549]ns-plain-safe-out
   c = flow-key  ⇒ [1550]ns-plain-safe-in
   [128] ns-plain-safe-out ::= [1551]ns-char
   [129] ns-plain-safe-in ::= [1552]ns-char - [1553]c-flow-indicator
   [130] ns-plain-char(c) ::=   ( [1554]ns-plain-safe(c) - [1555]“:” -
   [1556]“#” )
   | ( /* An [1557]ns-char preceding */ [1558]“#” )
   | ( [1559]“:” /* Followed by an [1560]ns-plain-safe(c) */ )

   Example 7.10. Plain Characters
# Outside flow collection:
- ::vector
- ": - ()"
- Up, up, and away!
- -123
- http://example.com/foo#bar
# Inside flow collection:
- [ ::vector,
  ": - ()",
  "Up, up and away!",
  -123,
  http://example.com/foo#bar ]

%YAML 1.2
---
!!seq [
  !!str "::vector",
  !!str ": - ()",
  !!str "Up, up, and away!",
  !!int "-123",
  !!str "http://example.com/foo#bar",
  !!seq [
    !!str "::vector",
    !!str ": - ()",
    !!str "Up, up, and away!",
    !!int "-123",
    !!str "http://example.com/foo#bar",
  ],
]

Legend:
  [1561]ns-plain-first(c) Not ns-plain-first(c) [1562]ns-plain-char(c) Not ns-pl
ain-char(c)

   Plain scalars are further restricted to a single line when contained
   inside an [1563]implicit key.
   [131] ns-plain(n,c) ::= c = flow-out  ⇒ [1564]ns-plain-multi-line(n,c)
   c = flow-in   ⇒ [1565]ns-plain-multi-line(n,c)
   c = block-key ⇒ [1566]ns-plain-one-line(c)
   c = flow-key  ⇒ [1567]ns-plain-one-line(c)
   [132] nb-ns-plain-in-line(c) ::= ( [1568]s-white*
   [1569]ns-plain-char(c) )*
   [133] ns-plain-one-line(c) ::= [1570]ns-plain-first(c)
   [1571]nb-ns-plain-in-line(c)

   Example 7.11. Plain Implicit Keys
implicit block key : [
  implicit flow key : value,
 ]

Legend:
  [1572]ns-plain-one-line(c)

%YAML 1.2
---
!!map {
  ? !!str "implicit block key"
  : !!seq [
    !!map {
      ? !!str "implicit flow key"
      : !!str "value",
    }
  ]
}

   All leading and trailing [1573]white space characters are excluded from
   the [1574]content. Each continuation line must therefore contain at
   least one non-[1575]space character. Empty lines, if any, are consumed
   as part of the [1576]line folding.
   [134] s-ns-plain-next-line(n,c) ::= [1577]s-flow-folded(n)
   [1578]ns-plain-char(c) [1579]nb-ns-plain-in-line(c)
   [135] ns-plain-multi-line(n,c) ::= [1580]ns-plain-one-line(c)
   [1581]s-ns-plain-next-line(n,c)*

   Example 7.12. Plain Lines
1st non-empty↓
↓
·2nd non-empty·
→3rd non-empty

%YAML 1.2
---
!!str "1st non-empty\n\
      2nd non-empty \
      3rd non-empty"

Legend:
  [1582]nb-ns-plain-in-line(c) [1583]s-ns-plain-next-line(n,c)

7.4. Flow Collection Styles

   A flow collection may be nested within a [1584]block collection
   ([1585]flow-out context), nested within another flow collection
   ([1586]flow-in context), or be a part of an [1587]implicit key
   ([1588]flow-key context or [1589]block-key context). Flow collection
   entries are terminated by the “,” indicator. The final “,” may be
   omitted. This does not cause ambiguity because flow collection entries
   can never be [1590]completely empty.
   [136] in-flow(c) ::= c = flow-out  ⇒ flow-in
   c = flow-in   ⇒ flow-in
   c = block-key ⇒ flow-key
   c = flow-key  ⇒ flow-key

7.4.1. Flow Sequences

   Flow sequence content is denoted by surrounding “[” and “]” characters.
   [137] c-flow-sequence(n,c) ::= [1591]“[” [1592]s-separate(n,c)?
   [1593]ns-s-flow-seq-entries(n,[1594]in-flow(c)[1595])? [1596]“]”

   Sequence entries are separated by a [1597]“,” character.
   [138] ns-s-flow-seq-entries(n,c) ::= [1598]ns-flow-seq-entry(n,c)
   [1599]s-separate(n,c)?
   ( [1600]“,” [1601]s-separate(n,c)?
     [1602]ns-s-flow-seq-entries(n,c)? )?

   Example 7.13. Flow Sequence
- [ one, two, ]
- [three ,four]

Legend:
  [1603]c-sequence-start [1604]c-sequence-end
  [1605]ns-flow-seq-entry(n,c)

%YAML 1.2
---
!!seq [
  !!seq [
    !!str "one",
    !!str "two",
  ],
  !!seq [
    !!str "three",
    !!str "four",
  ],
]

   Any [1606]flow node may be used as a flow sequence entry. In addition,
   YAML provides a [1607]compact notation for the case where a flow
   sequence entry is a [1608]mapping with a [1609]single key: value pair.
   [139] ns-flow-seq-entry(n,c) ::= [1610]ns-flow-pair(n,c) |
   [1611]ns-flow-node(n,c)

   Example 7.14. Flow Sequence Entries
[
"double
 quoted", 'single
           quoted',
plain
 text, [ nested ],
single: pair,
]

Legend:
  [1612]ns-flow-node(n,c) [1613]ns-flow-pair(n,c)

%YAML 1.2
---
!!seq [
  !!str "double quoted",
  !!str "single quoted",
  !!str "plain text",
  !!seq [
    !!str "nested",
  ],
  !!map {
    ? !!str "single"
    : !!str "pair",
  },
]

7.4.2. Flow Mappings

   Flow mappings are denoted by surrounding “{” and “}” characters.
   [140] c-flow-mapping(n,c) ::= [1614]“{” [1615]s-separate(n,c)?
   [1616]ns-s-flow-map-entries(n,[1617]in-flow(c)[1618])? [1619]“}”

   Mapping entries are separated by a [1620]“,” character.
   [141] ns-s-flow-map-entries(n,c) ::= [1621]ns-flow-map-entry(n,c)
   [1622]s-separate(n,c)?
   ( [1623]“,” [1624]s-separate(n,c)?
     [1625]ns-s-flow-map-entries(n,c)? )?

   Example 7.15. Flow Mappings
- { one : two , three: four , }
- {five: six,seven : eight}

Legend:
  [1626]c-mapping-start [1627]c-mapping-end
  [1628]ns-flow-map-entry(n,c)

%YAML 1.2
---
!!seq [
  !!map {
    ? !!str "one"   : !!str "two",
    ? !!str "three" : !!str "four",
  },
  !!map {
    ? !!str "five"  : !!str "six",
    ? !!str "seven" : !!str "eight",
  },
]

   If the optional “?” mapping key indicator is specified, the rest of the
   entry may be [1629]completely empty.
   [142] ns-flow-map-entry(n,c) ::=   ( [1630]“?” [1631]s-separate(n,c)
       [1632]ns-flow-map-explicit-entry(n,c) )
   | [1633]ns-flow-map-implicit-entry(n,c)
   [143] ns-flow-map-explicit-entry(n,c) ::=
   [1634]ns-flow-map-implicit-entry(n,c)
   | ( [1635]e-node /* Key */
       [1636]e-node /* Value */ )

   Example 7.16. Flow Mapping Entries
{
? explicit: entry,
implicit: entry,
?°°
}

Legend:
  [1637]ns-flow-map-explicit-entry(n,c)
  [1638]ns-flow-map-implicit-entry(n,c)
  [1639]e-node

%YAML 1.2
---
!!map {
  ? !!str "explicit" : !!str "entry",
  ? !!str "implicit" : !!str "entry",
  ? !!null "" : !!null "",
}

   Normally, YAML insists the “:” mapping value indicator be
   [1640]separated from the [1641]value by [1642]white space. A benefit of
   this restriction is that the “:” character can be used inside
   [1643]plain scalars, as long as it is not followed by [1644]white
   space. This allows for unquoted URLs and timestamps. It is also a
   potential source for confusion as “a:1” is a [1645]plain scalar and not
   a [1646]key: value pair.

   Note that the [1647]value may be [1648]completely empty since its
   existence is indicated by the “:”.
   [144] ns-flow-map-implicit-entry(n,c) ::=
   [1649]ns-flow-map-yaml-key-entry(n,c)
   | [1650]c-ns-flow-map-empty-key-entry(n,c)
   | [1651]c-ns-flow-map-json-key-entry(n,c)
   [145] ns-flow-map-yaml-key-entry(n,c) ::= [1652]ns-flow-yaml-node(n,c)
   ( ( [1653]s-separate(n,c)?
       [1654]c-ns-flow-map-separate-value(n,c) )
   | [1655]e-node )
   [146] c-ns-flow-map-empty-key-entry(n,c) ::= [1656]e-node /* Key */
   [1657]c-ns-flow-map-separate-value(n,c)
   [147] c-ns-flow-map-separate-value(n,c) ::= [1658]“:” /* Not followed
   by an
          [1659]ns-plain-safe(c) */
   ( ( [1660]s-separate(n,c) [1661]ns-flow-node(n,c) )
   | [1662]e-node /* Value */ )

   Example 7.17. Flow Mapping Separate Values
{
unquoted·:·"separate",
http://foo.com,
omitted value:°,
°:·omitted key,
}

Legend:
  [1663]ns-flow-yaml-node(n,c) [1664]e-node
  [1665]c-ns-flow-map-separate-value(n,c)

%YAML 1.2
---
!!map {
  ? !!str "unquoted" : !!str "separate",
  ? !!str "http://foo.com" : !!null "",
  ? !!str "omitted value" : !!null "",
  ? !!null "" : !!str "omitted key",
}

   To ensure [1666]JSON compatibility, if a [1667]key inside a flow
   mapping is [1668]JSON-like, YAML allows the following [1669]value to be
   specified adjacent to the “:”. This causes no ambiguity, as all
   [1670]JSON-like [1671]keys are surrounded by [1672]indicators. However,
   as this greatly reduces readability, YAML [1673]processors should
   [1674]separate the [1675]value from the “:” on output, even in this
   case.
   [148] c-ns-flow-map-json-key-entry(n,c) ::= [1676]c-flow-json-node(n,c)
   ( ( [1677]s-separate(n,c)?
       [1678]c-ns-flow-map-adjacent-value(n,c) )
   | [1679]e-node )
   [149] c-ns-flow-map-adjacent-value(n,c) ::= [1680]“:” ( (
   [1681]s-separate(n,c)?
           [1682]ns-flow-node(n,c) )
       | [1683]e-node ) /* Value */

   Example 7.18. Flow Mapping Adjacent Values
{
"adjacent":value,
"readable":·value,
"empty":°
}

Legend:
  [1684]c-flow-json-node(n,c) [1685]e-node
  [1686]c-ns-flow-map-adjacent-value(n,c)

%YAML 1.2
---
!!map {
  ? !!str "adjacent" : !!str "value",
  ? !!str "readable" : !!str "value",
  ? !!str "empty"    : !!null "",
}

   A more compact notation is usable inside [1687]flow sequences, if the
   [1688]mapping contains a single key: value pair. This notation does not
   require the surrounding “{” and “}” characters. Note that it is not
   possible to specify any [1689]node properties for the [1690]mapping in
   this case.

   Example 7.19. Single Pair Flow Mappings
[
foo: bar
]

Legend:
  [1691]ns-flow-pair(n,c)

%YAML 1.2
---
!!seq [
  !!map { ? !!str "foo" : !!str "bar" }
]

   If the “?” indicator is explicitly specified, [1692]parsing is
   unambiguous, and the syntax is identical to the general case.
   [150] ns-flow-pair(n,c) ::=   ( [1693]“?” [1694]s-separate(n,c)
       [1695]ns-flow-map-explicit-entry(n,c) )
   | [1696]ns-flow-pair-entry(n,c)

   Example 7.20. Single Pair Explicit Entry
[
? foo
 bar : baz
]

Legend:
  [1697]ns-flow-map-explicit-entry(n,c)

%YAML 1.2
---
!!seq [
  !!map {
    ? !!str "foo bar"
    : !!str "baz",
  },
]

   If the “?” indicator is omitted, [1698]parsing needs to see past the
   implicit key to recognize it as such. To limit the amount of lookahead
   required, the “:” indicator must appear at most 1024 Unicode characters
   beyond the start of the [1699]key. In addition, the [1700]key is
   restricted to a single line.

   Note that YAML allows arbitrary [1701]nodes to be used as [1702]keys.
   In particular, a [1703]key may be a [1704]sequence or a [1705]mapping.
   Thus, without the above restrictions, practical one-pass [1706]parsing
   would have been impossible to implement.
   [151] ns-flow-pair-entry(n,c) ::=
   [1707]ns-flow-pair-yaml-key-entry(n,c)
   | [1708]c-ns-flow-map-empty-key-entry(n,c)
   | [1709]c-ns-flow-pair-json-key-entry(n,c)
   [152] ns-flow-pair-yaml-key-entry(n,c) ::=
   [1710]ns-s-implicit-yaml-key(flow-key)
   [1711]c-ns-flow-map-separate-value(n,c)
   [153] c-ns-flow-pair-json-key-entry(n,c) ::=
   [1712]c-s-implicit-json-key(flow-key)
   [1713]c-ns-flow-map-adjacent-value(n,c)
   [154] ns-s-implicit-yaml-key(c) ::= [1714]ns-flow-yaml-node(n/a,c)
   [1715]s-separate-in-line?
   /* At most 1024 characters altogether */
   [155] c-s-implicit-json-key(c) ::= [1716]c-flow-json-node(n/a,c)
   [1717]s-separate-in-line?
   /* At most 1024 characters altogether */

   Example 7.21. Single Pair Implicit Entries
- [ YAML·: separate ]
- [ °: empty key entry ]
- [ {JSON: like}:adjacent ]

Legend:
  [1718]ns-s-implicit-yaml-key
  [1719]c-s-implicit-json-key
  [1720]e-node Value

%YAML 1.2
---
!!seq [
  !!seq [
    !!map {
      ? !!str "YAML"
      : !!str "separate"
    },
  ],
  !!seq [
    !!map {
      ? !!null ""
      : !!str "empty key entry"
    },
  ],
  !!seq [
    !!map {
      ? !!map {
        ? !!str "JSON"
        : !!str "like"
      } : "adjacent",
    },
  ],
]

   Example 7.22. Invalid Implicit Keys
[ foo
 bar: invalid,
 "foo...>1K characters...bar": invalid ]

ERROR:
- The foo bar key spans multiple lines
- The foo...bar key is too long

7.5. Flow Nodes

   JSON-like [1721]flow styles all have explicit start and end
   [1722]indicators. The only [1723]flow style that does not have this
   property is the [1724]plain scalar. Note that none of the “JSON-like”
   styles is actually acceptable by JSON. Even the [1725]double-quoted
   style is a superset of the JSON string format.
   [156] ns-flow-yaml-content(n,c) ::= [1726]ns-plain(n,c)
   [157] c-flow-json-content(n,c) ::=   [1727]c-flow-sequence(n,c) |
   [1728]c-flow-mapping(n,c)
   | [1729]c-single-quoted(n,c) | [1730]c-double-quoted(n,c)
   [158] ns-flow-content(n,c) ::= [1731]ns-flow-yaml-content(n,c) |
   [1732]c-flow-json-content(n,c)

   Example 7.23. Flow Content
- [ a, b ]
- { a: b }
- "a"
- 'b'
- c

Legend:
  [1733]c-flow-json-content(n,c)
  [1734]ns-flow-yaml-content(n,c)

%YAML 1.2
---
!!seq [
  !!seq [ !!str "a", !!str "b" ],
  !!map { ? !!str "a" : !!str "b" },
  !!str "a",
  !!str "b",
  !!str "c",
]

   A complete [1735]flow [1736]node also has optional [1737]node
   properties, except for [1738]alias nodes which refer to the
   [1739]anchored [1740]node properties.
   [159] ns-flow-yaml-node(n,c) ::=   [1741]c-ns-alias-node
   | [1742]ns-flow-yaml-content(n,c)
   | ( [1743]c-ns-properties(n,c)
       ( ( [1744]s-separate(n,c)
           [1745]ns-flow-yaml-content(n,c) )
         | [1746]e-scalar ) )
   [160] c-flow-json-node(n,c) ::= ( [1747]c-ns-properties(n,c)
   [1748]s-separate(n,c) )?
   [1749]c-flow-json-content(n,c)
   [161] ns-flow-node(n,c) ::=   [1750]c-ns-alias-node
   | [1751]ns-flow-content(n,c)
   | ( [1752]c-ns-properties(n,c)
       ( ( [1753]s-separate(n,c)
           [1754]ns-flow-content(n,c) )
         | [1755]e-scalar ) )

   Example 7.24. Flow Nodes
- !!str "a"
- 'b'
- &anchor "c"
- *anchor
- !!str°

Legend:
  [1756]c-flow-json-node(n,c)
  [1757]ns-flow-yaml-node(n,c)

%YAML 1.2
---
!!seq [
  !!str "a",
  !!str "b",
  &A !!str "c",
  *A,
  !!str "",
]

Chapter 8. Block Styles

   YAML’s block styles employ [1758]indentation rather than
   [1759]indicators to denote structure. This results in a more human
   readable (though less compact) notation.

8.1. Block Scalar Styles

   YAML provides two block scalar styles, [1760]literal and [1761]folded.
   Each provides a different trade-off between readability and expressive
   power.

8.1.1. Block Scalar Headers

   [1762]Block scalars are controlled by a few [1763]indicators given in a
   header preceding the [1764]content itself. This header is followed by a
   non-content [1765]line break with an optional [1766]comment. This is
   the only case where a [1767]comment must not be followed by additional
   [1768]comment lines.
   [162] c-b-block-header(m,t) ::= ( ( [1769]c-indentation-indicator(m)
       [1770]c-chomping-indicator(t) )
   | ( [1771]c-chomping-indicator(t)
       [1772]c-indentation-indicator(m) ) )
   [1773]s-b-comment

   Example 8.1. Block Scalar Header
- | # Empty header↓
 literal
- >1 # Indentation indicator↓
 ·folded
- |+ # Chomping indicator↓
 keep

- >1- # Both indicators↓
 ·strip


%YAML 1.2
---
!!seq [
  !!str "literal\n",
  !!str "·folded\n",
  !!str "keep\n\n",
  !!str "·strip",
]

 Legend:
   [1774]c-b-block-header(m,t)

8.1.1.1. Block Indentation Indicator

   Typically, the [1775]indentation level of a [1776]block scalar is
   detected from its first non-[1777]empty line. It is an error for any of
   the leading [1778]empty lines to contain more [1779]spaces than the
   first non-[1780]empty line.

   Detection fails when the first non-[1781]empty line contains leading
   content [1782]space characters. [1783]Content may safely start with a
   [1784]tab or a [1785]“#” character.

   When detection would fail, YAML requires that the [1786]indentation
   level for the [1787]content be given using an explicit indentation
   indicator. This level is specified as the integer number of the
   additional [1788]indentation spaces used for the [1789]content,
   relative to its parent [1790]node.

   It is always valid to specify an indentation indicator for a
   [1791]block scalar node, though a YAML [1792]processor should only emit
   an explicit indentation indicator for cases where detection will fail.
   [163] c-indentation-indicator(m) ::= [1793]ns-dec-digit ⇒ m =
   [1794]ns-dec-digit - #x30
   /* Empty */  ⇒ m = auto-detect()

   Example 8.2. Block Indentation Indicator
- |°
·detected
- >°
·
··
··# detected
- |1
··explicit
- >°
·→
·detected

%YAML 1.2
---
!!seq [
  !!str "detected\n",
  !!str "\n\n# detected\n",
  !!str "·explicit\n",
  !!str "\t·detected\n",
]

 Legend:
   [1795]c-indentation-indicator(m)
   [1796]s-indent(n)

   Example 8.3. Invalid Block Scalar Indentation Indicators
- |
··
·text
- >
··text
·text
- |2
·text

ERROR:
- A leading all-space line must
  not have too many spaces.
- A following text line must
  not be less indented.
- The text is less indented
  than the indicated level.

8.1.1.2. Block Chomping Indicator

   Chomping controls how final [1797]line breaks and trailing [1798]empty
   lines are interpreted. YAML provides three chomping methods:

   Strip
          Stripping is specified by the “-” chomping indicator. In this
          case, the final [1799]line break and any trailing [1800]empty
          lines are excluded from the [1801]scalar’s content.

   Clip
          Clipping is the default behavior used if no explicit chomping
          indicator is specified. In this case, the final [1802]line break
          character is preserved in the [1803]scalar’s content. However,
          any trailing [1804]empty lines are excluded from the
          [1805]scalar’s content.

   Keep
          Keeping is specified by the “+” chomping indicator. In this
          case, the final [1806]line break and any trailing [1807]empty
          lines are considered to be part of the [1808]scalar’s content.
          These additional lines are not subject to [1809]folding.

   The chomping method used is a [1810]presentation detail and must not be
   used to convey [1811]content information.
   [164] c-chomping-indicator(t) ::= “-”         ⇒ t = strip
   “+”         ⇒ t = keep
   /* Empty */ ⇒ t = clip

   The interpretation of the final [1812]line break of a [1813]block
   scalar is controlled by the chomping indicator specified in the
   [1814]block scalar header.
   [165] b-chomped-last(t) ::= t = strip ⇒ [1815]b-non-content | /* End of
   file */
   t = clip  ⇒ [1816]b-as-line-feed | /* End of file */
   t = keep  ⇒ [1817]b-as-line-feed | /* End of file */

   Example 8.4. Chomping Final Line Break
strip: |-
  text↓
clip: |
  text↓
keep: |+
  text↓

Legend:
  [1818]b-non-content [1819]b-as-line-feed

%YAML 1.2
---
!!map {
  ? !!str "strip"
  : !!str "text",
  ? !!str "clip"
  : !!str "text\n",
  ? !!str "keep"
  : !!str "text\n",
}

   The interpretation of the trailing [1820]empty lines following a
   [1821]block scalar is also controlled by the chomping indicator
   specified in the [1822]block scalar header.
   [166] l-chomped-empty(n,t) ::= t = strip ⇒ [1823]l-strip-empty(n)
   t = clip  ⇒ [1824]l-strip-empty(n)
   t = keep  ⇒ [1825]l-keep-empty(n)
   [167] l-strip-empty(n) ::= ( [1826]s-indent(≤n) [1827]b-non-content )*
   [1828]l-trail-comments(n)?
   [168] l-keep-empty(n) ::= [1829]l-empty(n,block-in)*
   [1830]l-trail-comments(n)?

   Explicit [1831]comment lines may follow the trailing [1832]empty lines.
   To prevent ambiguity, the first such [1833]comment line must be less
   [1834]indented than the [1835]block scalar content. Additional
   [1836]comment lines, if any, are not so restricted. This is the only
   case where the [1837]indentation of [1838]comment lines is constrained.
   [169] l-trail-comments(n) ::= [1839]s-indent(<n)
   [1840]c-nb-comment-text [1841]b-comment
   [1842]l-comment*

   Example 8.5. Chomping Trailing Lines
 # Strip
  # Comments:
strip: |-
  # text↓
··⇓
·# Clip
··# comments:
↓
clip: |
  # text↓
·↓
·# Keep
··# comments:
↓
keep: |+
  # text↓
↓
·# Trail
··# comments.

%YAML 1.2
---
!!map {
  ? !!str "strip"
  : !!str "# text",
  ? !!str "clip"
  : !!str "# text\n",
  ? !!str "keep"
  : !!str "# text\n",
}

 Legend:
   [1843]l-strip-empty(n)
   [1844]l-keep-empty(n)
   [1845]l-trail-comments(n)

   If a [1846]block scalar consists only of [1847]empty lines, then these
   lines are considered as trailing lines and hence are affected by
   chomping.

   Example 8.6. Empty Scalar Chomping
strip: >-
↓
clip: >
↓
keep: |+
↓

Legend:
  [1848]l-strip-empty(n) [1849]l-keep-empty(n)

%YAML 1.2
---
!!map {
  ? !!str "strip"
  : !!str "",
  ? !!str "clip"
  : !!str "",
  ? !!str "keep"
  : !!str "\n",
}

8.1.2. Literal Style

   The literal style is denoted by the “|” indicator. It is the simplest,
   most restricted, and most readable [1850]scalar style.
   [170] c-l+literal(n) ::= [1851]“|” [1852]c-b-block-header(m,t)
   [1853]l-literal-content(n+m,t)

   Example 8.7. Literal Scalar
|↓
·literal↓
·→text↓
↓

Legend:
  [1854]c-l+literal(n)

%YAML 1.2
---
!!str "literal\n\ttext\n"

   Inside literal scalars, all ([1855]indented) characters are considered
   to be [1856]content, including [1857]white space characters. Note that
   all [1858]line break characters are [1859]normalized. In addition,
   [1860]empty lines are not [1861]folded, though final [1862]line breaks
   and trailing [1863]empty lines are [1864]chomped.

   There is no way to escape characters inside literal scalars. This
   restricts them to [1865]printable characters. In addition, there is no
   way to break a long literal line.
   [171] l-nb-literal-text(n) ::= [1866]l-empty(n,block-in)*
   [1867]s-indent(n) [1868]nb-char+
   [172] b-nb-literal-next(n) ::= [1869]b-as-line-feed
   [1870]l-nb-literal-text(n)
   [173] l-literal-content(n,t) ::= ( [1871]l-nb-literal-text(n)
   [1872]b-nb-literal-next(n)*
     [1873]b-chomped-last(t) )?
   [1874]l-chomped-empty(n,t)

   Example 8.8. Literal Content
|
·
··
··literal↓
···↓
··
··text↓
↓
·# Comment

%YAML 1.2
---
!!str "\n\nliteral\n·\n\ntext\n"

 Legend:
   [1875]l-nb-literal-text(n)
   [1876]b-nb-literal-next(n)
   [1877]b-chomped-last(t)
   [1878]l-chomped-empty(n,t)

8.1.3. Folded Style

   The folded style is denoted by the “>” indicator. It is similar to the
   [1879]literal style; however, folded scalars are subject to [1880]line
   folding.
   [174] c-l+folded(n) ::= [1881]“>” [1882]c-b-block-header(m,t)
   [1883]l-folded-content(n+m,t)

   Example 8.9. Folded Scalar
>↓
·folded↓
·text↓
↓

%YAML 1.2
---
!!str "folded text\n"

Legend:
  [1884]c-l+folded(n)

   [1885]Folding allows long lines to be broken anywhere a single
   [1886]space character separates two non-[1887]space characters.
   [175] s-nb-folded-text(n) ::= [1888]s-indent(n) [1889]ns-char
   [1890]nb-char*
   [176] l-nb-folded-lines(n) ::= [1891]s-nb-folded-text(n)
   ( [1892]b-l-folded(n,block-in) [1893]s-nb-folded-text(n) )*

   Example 8.10. Folded Lines
>

·folded↓
·line↓
↓
·next
·line↓
   * bullet

   * list
   * lines

·last↓
·line↓

# Comment

%YAML 1.2
---
!!str "\n\
      folded line\n\
      next line\n\
      \  * bullet\n
      \n\
      \  * list\n\
      \  * lines\n\
      \n\
      last line\n"

 Legend:
   [1894]s-nb-folded-text(n)
   [1895]l-nb-folded-lines(n)

   (The following three examples duplicate this example, each highlighting
   different productions.)

   Lines starting with [1896]white space characters (more-indented lines)
   are not [1897]folded.
   [177] s-nb-spaced-text(n) ::= [1898]s-indent(n) [1899]s-white
   [1900]nb-char*
   [178] b-l-spaced(n) ::= [1901]b-as-line-feed
   [1902]l-empty(n,block-in)*
   [179] l-nb-spaced-lines(n) ::= [1903]s-nb-spaced-text(n)
   ( [1904]b-l-spaced(n) [1905]s-nb-spaced-text(n) )*

   Example 8.11. More Indented Lines
>

 folded
 line

 next
 line
···* bullet↓
↓
···* list↓
···* lines↓

 last
 line

# Comment

%YAML 1.2
---
!!str "\n\
      folded line\n\
      next line\n\
      \  * bullet\n
      \n\
      \  * list\n\
      \  * lines\n\
      \n\
      last line\n"

 Legend:
   [1906]s-nb-spaced-text(n)
   [1907]l-nb-spaced-lines(n)

   [1908]Line breaks and [1909]empty lines separating folded and
   more-indented lines are also not [1910]folded.
   [180] l-nb-same-lines(n) ::= [1911]l-empty(n,block-in)*
   ( [1912]l-nb-folded-lines(n) | [1913]l-nb-spaced-lines(n) )
   [181] l-nb-diff-lines(n) ::= [1914]l-nb-same-lines(n)
   ( [1915]b-as-line-feed [1916]l-nb-same-lines(n) )*

   Example 8.12. Empty Separation Lines
>
↓
 folded
 line↓
↓
 next
 line↓
   * bullet

   * list
   * line↓
↓
 last
 line

# Comment

%YAML 1.2
---
!!str "\n\
      folded line\n\
      next line\n\
      \  * bullet\n
      \n\
      \  * list\n\
      \  * lines\n\
      \n\
      last line\n"

 Legend:
   [1917]b-as-line-feed
   (separation) [1918]l-empty(n,c)

   The final [1919]line break, and trailing [1920]empty lines if any, are
   subject to [1921]chomping and are never [1922]folded.
   [182] l-folded-content(n,t) ::= ( [1923]l-nb-diff-lines(n)
   [1924]b-chomped-last(t) )?
   [1925]l-chomped-empty(n,t)

   Example 8.13. Final Empty Lines
>
 folded
 line

 next
 line
   * bullet

   * list
   * line

 last
 line↓
↓
# Comment

%YAML 1.2
---
!!str "\n\
      folded line\n\
      next line\n\
      \  * bullet\n
      \n\
      \  * list\n\
      \  * lines\n\
      \n\
      last line\n"

 Legend:
   [1926]b-chomped-last(t) [1927]l-chomped-empty(n,t)

8.2. Block Collection Styles

   For readability, block collections styles are not denoted by any
   [1928]indicator. Instead, YAML uses a lookahead method, where a block
   collection is distinguished from a [1929]plain scalar only when a
   [1930]key: value pair or a [1931]sequence entry is seen.

8.2.1. Block Sequences

   A block sequence is simply a series of [1932]nodes, each denoted by a
   leading “-” indicator. The “-” indicator must be [1933]separated from
   the [1934]node by [1935]white space. This allows “-” to be used as the
   first character in a [1936]plain scalar if followed by a non-space
   character (e.g. “-1”).
   [183] l+block-sequence(n) ::= ( [1937]s-indent(n+m)
   [1938]c-l-block-seq-entry(n+m) )+
   /* For some fixed auto-detected m > 0 */
   [184] c-l-block-seq-entry(n) ::= [1939]“-” /* Not followed by an
   [1940]ns-char */
   [1941]s-l+block-indented(n,block-in)

   Example 8.14. Block Sequence
block sequence:
··- one↓
  - two : three↓

Legend:
  [1942]c-l-block-seq-entry(n)
  auto-detected [1943]s-indent(n)

%YAML 1.2
---
!!map {
  ? !!str "block sequence"
  : !!seq [
    !!str "one",
    !!map {
      ? !!str "two"
      : !!str "three"
    },
  ],
}

   The entry [1944]node may be either [1945]completely empty, be a nested
   [1946]block node, or use a compact in-line notation. The compact
   notation may be used when the entry is itself a nested [1947]block
   collection. In this case, both the “-” indicator and the following
   [1948]spaces are considered to be part of the [1949]indentation of the
   nested [1950]collection. Note that it is not possible to specify
   [1951]node properties for such a [1952]collection.
   [185] s-l+block-indented(n,c) ::=   ( [1953]s-indent(m)
       ( [1954]ns-l-compact-sequence(n+1+m)
       | [1955]ns-l-compact-mapping(n+1+m) ) )
   | [1956]s-l+block-node(n,c)
   | ( [1957]e-node [1958]s-l-comments )
   [186] ns-l-compact-sequence(n) ::= [1959]c-l-block-seq-entry(n)
   ( [1960]s-indent(n) [1961]c-l-block-seq-entry(n) )*

   Example 8.15. Block Sequence Entry Types
-° # Empty
- |
 block node
-·- one # Compact
··- two # sequence
- one: two # Compact mapping

Legend:
  Empty
  [1962]s-l+block-node(n,c)
  [1963]ns-l-compact-sequence(n)
  [1964]ns-l-compact-mapping(n)

%YAML 1.2
---
!!seq [
  !!null "",
  !!str "block node\n",
  !!seq [
    !!str "one"
    !!str "two",
  ],
  !!map {
    ? !!str "one"
    : !!str "two",
  },
]

8.2.2. Block Mappings

   A Block mapping is a series of entries, each [1965]presenting a
   [1966]key: value pair.
   [187] l+block-mapping(n) ::= ( [1967]s-indent(n+m)
   [1968]ns-l-block-map-entry(n+m) )+
   /* For some fixed auto-detected m > 0 */

   Example 8.16. Block Mappings
block mapping:
·key: value↓

Legend:
  [1969]ns-l-block-map-entry(n)
  auto-detected [1970]s-indent(n)

%YAML 1.2
---
!!map {
  ? !!str "block mapping"
  : !!map {
    ? !!str "key"
    : !!str "value",
  },
}

   If the [1971]“?” indicator is specified, the optional value node must
   be specified on a separate line, denoted by the [1972]“:” indicator.
   Note that YAML allows here the same [1973]compact in-line notation
   described above for [1974]block sequence entries.
   [188] ns-l-block-map-entry(n) ::=
   [1975]c-l-block-map-explicit-entry(n)
   | [1976]ns-l-block-map-implicit-entry(n)
   [189] c-l-block-map-explicit-entry(n) ::=
   [1977]c-l-block-map-explicit-key(n)
   ( [1978]l-block-map-explicit-value(n)
   | [1979]e-node )
   [190] c-l-block-map-explicit-key(n) ::= [1980]“?”
   [1981]s-l+block-indented(n,block-out)
   [191] l-block-map-explicit-value(n) ::= [1982]s-indent(n)
   [1983]“:” [1984]s-l+block-indented(n,block-out)

   Example 8.17. Explicit Block Mapping Entries
? explicit key # Empty value↓°
? |
  block key↓
:·- one # Explicit compact
··- two # block value↓

Legend:
  [1985]c-l-block-map-explicit-key(n)
  [1986]l-block-map-explicit-value(n)
  [1987]e-node

%YAML 1.2
---
!!map {
  ? !!str "explicit key"
  : !!str "",
  ? !!str "block key\n"
  : !!seq [
    !!str "one",
    !!str "two",
  ],
}

   If the “?” indicator is omitted, [1988]parsing needs to see past the
   [1989]implicit key, in the same way as in the [1990]single key: value
   pair [1991]flow mapping. Hence, such [1992]keys are subject to the same
   restrictions; they are limited to a single line and must not span more
   than 1024 Unicode characters.
   [192] ns-l-block-map-implicit-entry(n) ::= (
   [1993]ns-s-block-map-implicit-key
   | [1994]e-node )
   [1995]c-l-block-map-implicit-value(n)
   [193] ns-s-block-map-implicit-key ::=
   [1996]c-s-implicit-json-key(block-key)
   | [1997]ns-s-implicit-yaml-key(block-key)

   In this case, the [1998]value may be specified on the same line as the
   [1999]implicit key. Note however that in block mappings the [2000]value
   must never be adjacent to the “:”, as this greatly reduces readability
   and is not required for [2001]JSON compatibility (unlike the case in
   [2002]flow mappings).

   There is no compact notation for in-line [2003]values. Also, while both
   the [2004]implicit key and the [2005]value following it may be empty,
   the [2006]“:” indicator is mandatory. This prevents a potential
   ambiguity with multi-line [2007]plain scalars.
   [194] c-l-block-map-implicit-value(n) ::= [2008]“:” (
   [2009]s-l+block-node(n,block-out)
       | ( [2010]e-node [2011]s-l-comments ) )

   Example 8.18. Implicit Block Mapping Entries
plain key: in-line value
°:° # Both empty
"quoted key":
- entry

Legend:
  [2012]ns-s-block-map-implicit-key
  [2013]c-l-block-map-implicit-value(n)

%YAML 1.2
---
!!map {
  ? !!str "plain key"
  : !!str "in-line value",
  ? !!null ""
  : !!null "",
  ? !!str "quoted key"
  : !!seq [ !!str "entry" ],
}

   A [2014]compact in-line notation is also available. This compact
   notation may be nested inside [2015]block sequences and explicit block
   mapping entries. Note that it is not possible to specify [2016]node
   properties for such a nested mapping.
   [195] ns-l-compact-mapping(n) ::= [2017]ns-l-block-map-entry(n)
   ( [2018]s-indent(n) [2019]ns-l-block-map-entry(n) )*

   Example 8.19. Compact Block Mappings
- sun: yellow↓
- ? earth: blue↓
  : moon: white↓

Legend:
  [2020]ns-l-compact-mapping(n)

%YAML 1.2
---
!!seq [
  !!map {
     !!str "sun" : !!str "yellow",
  },
  !!map {
    ? !!map {
      ? !!str "earth"
      : !!str "blue"
    },
    : !!map {
      ? !!str "moon"
      : !!str "white"
    },
  }
]

8.2.3. Block Nodes

   YAML allows [2021]flow nodes to be embedded inside [2022]block
   collections (but not vice-versa). [2023]Flow nodes must be
   [2024]indented by at least one more [2025]space than the parent
   [2026]block collection. Note that [2027]flow nodes may begin on a
   following line.

   It is at this point that [2028]parsing needs to distinguish between a
   [2029]plain scalar and an [2030]implicit key starting a nested
   [2031]block mapping.
   [196] s-l+block-node(n,c) ::= [2032]s-l+block-in-block(n,c) |
   [2033]s-l+flow-in-block(n)
   [197] s-l+flow-in-block(n) ::= [2034]s-separate(n+1,flow-out)
   [2035]ns-flow-node(n+1,flow-out) [2036]s-l-comments

   Example 8.20. Block Node Types
-↓
··"flow in block"↓
-·>
 Block scalar↓
-·!!map # Block collection
  foo : bar↓

Legend:
  [2037]s-l+flow-in-block(n)
  [2038]s-l+block-in-block(n,c)

%YAML 1.2
---
!!seq [
  !!str "flow in block",
  !!str "Block scalar\n",
  !!map {
    ? !!str "foo"
    : !!str "bar",
  },
]

   The block [2039]node’s properties may span across several lines. In
   this case, they must be [2040]indented by at least one more [2041]space
   than the [2042]block collection, regardless of the [2043]indentation of
   the [2044]block collection entries.
   [198] s-l+block-in-block(n,c) ::= [2045]s-l+block-scalar(n,c) |
   [2046]s-l+block-collection(n,c)
   [199] s-l+block-scalar(n,c) ::= [2047]s-separate(n+1,c)
   ( [2048]c-ns-properties(n+1,c) [2049]s-separate(n+1,c) )?
   ( [2050]c-l+literal(n) | [2051]c-l+folded(n) )

   Example 8.21. Block Scalar Nodes
literal: |2
··value
folded:↓
···!foo
··>1
·value

Legend:
  [2052]c-l+literal(n) [2053]c-l+folded(n)

%YAML 1.2
---
!!map {
  ? !!str "literal"
  : !!str "value",
  ? !!str "folded"
  : !<!foo> "value",
}

   Since people perceive the [2054]“-” indicator as [2055]indentation,
   nested [2056]block sequences may be [2057]indented by one less
   [2058]space to compensate, except, of course, if nested inside another
   [2059]block sequence ([2060]block-out context vs. [2061]block-in
   context).
   [200] s-l+block-collection(n,c) ::= ( [2062]s-separate(n+1,c)
   [2063]c-ns-properties(n+1,c) )?
   [2064]s-l-comments
   ( [2065]l+block-sequence([2066]seq-spaces(n,c)[2067])
   | [2068]l+block-mapping(n) )
   [201] seq-spaces(n,c) ::= c = block-out ⇒ n-1
   c = block-in  ⇒ n

   Example 8.22. Block Collection Nodes
sequence: !!seq
- entry
- !!seq
 - nested
mapping: !!map
 foo: bar

Legend:
  [2069]l+block-sequence(n)
  [2070]l+block-mapping(n)
  [2071]s-l+block-collection(n,c)

%YAML 1.2
---
!!map {
  ? !!str "sequence"
  : !!seq [
    !!str "entry",
    !!seq [ !!str "nested" ],
  ],
  ? !!str "mapping"
  : !!map {
    ? !!str "foo" : !!str "bar",
  },
}

Chapter 9. YAML Character Stream

9.1. Documents

   A YAML character [2072]stream may contain several documents. Each
   document is completely independent from the rest.

9.1.1. Document Prefix

   A document may be preceded by a prefix specifying the [2073]character
   encoding, and optional [2074]comment lines. Note that all
   [2075]documents in a stream must use the same [2076]character encoding.
   However it is valid to re-specify the [2077]encoding using a [2078]byte
   order mark for each [2079]document in the stream. This makes it easier
   to concatenate streams.

   The existence of the optional prefix does not necessarily indicate the
   existence of an actual [2080]document.
   [202] l-document-prefix ::= [2081]c-byte-order-mark? [2082]l-comment*

   Example 9.1. Document Prefix
⇔# Comment
# lines
Document

Legend:
  [2083]l-document-prefix

%YAML 1.2
---
!!str "Document"

9.1.2. Document Markers

   Using [2084]directives creates a potential ambiguity. It is valid to
   have a [2085]“%” character at the start of a line (e.g. as the first
   character of the second line of a [2086]plain scalar). How, then, to
   distinguish between an actual [2087]directive and a [2088]content line
   that happens to start with a [2089]“%” character?

   The solution is the use of two special marker lines to control the
   processing of [2090]directives, one at the start of a [2091]document
   and one at the end.

   At the start of a [2092]document, lines beginning with a [2093]“%”
   character are assumed to be [2094]directives. The (possibly empty) list
   of [2095]directives is terminated by a directives end marker line.
   Lines following this marker can safely use [2096]“%” as the first
   character.

   At the end of a [2097]document, a document end marker line is used to
   signal the [2098]parser to begin scanning for [2099]directives again.

   The existence of this optional document suffix does not necessarily
   indicate the existence of an actual following [2100]document.

   Obviously, the actual [2101]content lines are therefore forbidden to
   begin with either of these markers.
   [203] c-directives-end ::= “-” “-” “-”
   [204] c-document-end ::= “.” “.” “.”
   [205] l-document-suffix ::= [2102]c-document-end [2103]s-l-comments
   [206] c-forbidden ::= /* Start of line */
   ( [2104]c-directives-end | [2105]c-document-end )
   ( [2106]b-char | [2107]s-white | /* End of file */ )

   Example 9.2. Document Markers
%YAML 1.2
---
Document
... # Suffix

%YAML 1.2
---
!!str "Document"

Legend:
  [2108]c-directives-end [2109]c-document-end
  [2110]l-document-suffix

9.1.3. Bare Documents

   A bare document does not begin with any [2111]directives or
   [2112]marker lines. Such documents are very “clean” as they contain
   nothing other than the [2113]content. In this case, the first
   non-comment line may not start with a [2114]“%” first character.

   Document [2115]nodes are [2116]indented as if they have a parent
   [2117]indented at -1 [2118]spaces. Since a [2119]node must be more
   [2120]indented than its parent [2121]node, this allows the document’s
   [2122]node to be [2123]indented at zero or more [2124]spaces.
   [207] l-bare-document ::= [2125]s-l+block-node(-1,block-in)
   /* Excluding [2126]c-forbidden content */

   Example 9.3. Bare Documents
Bare
document
...
# No document
...
|
%!PS-Adobe-2.0 # Not the first line

%YAML 1.2
---
!!str "Bare document"
%YAML 1.2
---
!!str "%!PS-Adobe-2.0\n"

 Legend:
   [2127]l-bare-document

9.1.4. Explicit Documents

   An explicit document begins with an explicit [2128]directives end
   marker line but no [2129]directives. Since the existence of the
   [2130]document is indicated by this [2131]marker, the [2132]document
   itself may be [2133]completely empty.
   [208] l-explicit-document ::= [2134]c-directives-end
   ( [2135]l-bare-document
   | ( [2136]e-node [2137]s-l-comments ) )

   Example 9.4. Explicit Documents
---
{ matches
% : 20 }
...
---
# Empty
...

 Legend:
   [2138]l-explicit-document

%YAML 1.2
---
!!map {
  !!str "matches %": !!int "20"
}
...
%YAML 1.2
---
!!null ""

9.1.5. Directives Documents

   A directives document begins with some [2139]directives followed by an
   explicit [2140]directives end marker line.
   [209] l-directive-document ::= [2141]l-directive+
   [2142]l-explicit-document

   Example 9.5. Directives Documents
%YAML 1.2
--- |
%!PS-Adobe-2.0
...
%YAML1.2
---
# Empty
...

 Legend:
   [2143]l-explicit-document

%YAML 1.2
---
!!str "%!PS-Adobe-2.0\n"
...
%YAML 1.2
---
!!null ""

9.2. Streams

   A YAML stream consists of zero or more [2144]documents. Subsequent
   [2145]documents require some sort of separation [2146]marker line. If a
   [2147]document is not terminated by a [2148]document end marker line,
   then the following [2149]document must begin with a [2150]directives
   end marker line.

   The stream format is intentionally “sloppy” to better support common
   use cases, such as stream concatenation.
   [210] l-any-document ::=   [2151]l-directive-document
   | [2152]l-explicit-document
   | [2153]l-bare-document
   [211] l-yaml-stream ::= [2154]l-document-prefix* [2155]l-any-document?
   ( [2156]l-document-suffix+ [2157]l-document-prefix*
   [2158]l-any-document?
   | [2159]l-document-prefix* [2160]l-explicit-document? )*

   Example 9.6. Stream
Document
---
# Empty
...
%YAML 1.2
---
matches %: 20

 Legend:
   [2161]l-any-document
   [2162]l-document-suffix
   [2163]l-explicit-document

%YAML 1.2
---
!!str "Document"
...
%YAML 1.2
---
!!null ""
...
%YAML 1.2
---
!!map {
  !!str "matches %": !!int "20"
}

   A sequence of bytes is a well-formed stream if, taken as a whole, it
   complies with the above l-yaml-stream production.

   Some common use case that can take advantage of the YAML stream
   structure are:

   Appending to Streams
          Allowing multiple [2164]documents in a single stream makes YAML
          suitable for log files and similar [2165]applications. Note that
          each [2166]document is independent of the rest, allowing for
          heterogeneous log file entries.

   Concatenating Streams
          Concatenating two YAML streams requires both to use the same
          [2167]character encoding. In addition, it is necessary to
          separate the last [2168]document of the first stream and the
          first [2169]document of the second stream. This is easily
          ensured by inserting a [2170]document end marker between the two
          streams. Note that this is safe regardless of the content of
          either stream. In particular, either or both may be empty, and
          the first stream may or may not already contain such a marker.

   Communication Streams
          The [2171]document end marker allows signaling the end of a
          [2172]document without closing the stream or starting the next
          [2173]document. This allows the receiver to complete processing
          a [2174]document without having to wait for the next one to
          arrive. The sender may also transmit "keep-alive" messages in
          the form of [2175]comment lines or repeated [2176]document end
          markers without signalling the start of the next [2177]document.

Chapter 10. Recommended Schemas

   A YAML schema is a combination of a set of [2178]tags and a mechanism
   for [2179]resolving [2180]non-specific tags.

10.1. Failsafe Schema

   The failsafe schema is guaranteed to work with any YAML [2181]document.
   It is therefore the recommended [2182]schema for generic YAML tools. A
   YAML [2183]processor should therefore support this [2184]schema, at
   least as an option.

10.1.1. Tags

10.1.1.1. Generic Mapping

   URI:

          tag:yaml.org,2002:map

   Kind:

          [2185]Mapping.

   Definition:

          [2186]Represents an associative container, where each [2187]key
          is unique in the association and mapped to exactly one
          [2188]value. YAML places no restrictions on the type of
          [2189]keys; in particular, they are not restricted to being
          [2190]scalars. Example [2191]bindings to [2192]native types
          include Perl’s hash, Python’s dictionary, and Java’s Hashtable.

   Example 10.1. !!map Examples
Block style: !!map
  Clark : Evans
  Ingy  : döt Net
  Oren  : Ben-Kiki

Flow style: !!map { Clark: Evans, Ingy: döt Net, Oren: Ben-Kiki }

10.1.1.2. Generic Sequence

   URI:

          tag:yaml.org,2002:seq

   Kind:

          [2193]Sequence.

   Definition:

          [2194]Represents a collection indexed by sequential integers
          starting with zero. Example [2195]bindings to [2196]native types
          include Perl’s array, Python’s list or tuple, and Java’s array
          or Vector.

   Example 10.2. !!seq Examples
Block style: !!seq
- Clark Evans
- Ingy döt Net
- Oren Ben-Kiki

Flow style: !!seq [ Clark Evans, Ingy döt Net, Oren Ben-Kiki ]

10.1.1.3. Generic String

   URI:

          tag:yaml.org,2002:str

   Kind:

          [2197]Scalar.

   Definition:

          [2198]Represents a Unicode string, a sequence of zero or more
          Unicode characters. This type is usually [2199]bound to the
          [2200]native language’s string type, or, for languages lacking
          one (such as C), to a character array.

   Canonical Form:

          The obvious.

   Example 10.3. !!str Examples
Block style: !!str |-
  String: just a theory.

Flow style: !!str "String: just a theory."

10.1.2. Tag Resolution

   All [2201]nodes with the [2202]“!” non-specific tag are [2203]resolved,
   by the standard [2204]convention, to “tag:yaml.org,2002:seq”,
   “tag:yaml.org,2002:map”, or “tag:yaml.org,2002:str”, according to their
   [2205]kind.

   All [2206]nodes with the [2207]“?” non-specific tag are left
   [2208]unresolved. This constrains the [2209]application to deal with a
   [2210]partial representation.

10.2. JSON Schema

   The JSON schema is the lowest common denominator of most modern
   computer languages, and allows [2211]parsing JSON files. A YAML
   [2212]processor should therefore support this [2213]schema, at least as
   an option. It is also strongly recommended that other [2214]schemas
   should be based on it.

10.2.1. Tags

   The JSON [2215]schema uses the following [2216]tags in addition to
   those defined by the [2217]failsafe schema:

10.2.1.1. Null

   URI:

          tag:yaml.org,2002:null

   Kind:

          [2218]Scalar.

   Definition:

          [2219]Represents the lack of a value. This is typically
          [2220]bound to a [2221]native null-like value (e.g., undef in
          Perl, None in Python). Note that a null is different from an
          empty string. Also, a [2222]mapping entry with some [2223]key
          and a null [2224]value is valid, and different from not having
          that [2225]key in the [2226]mapping.

   Canonical Form:

          null.

   Example 10.4. !!null Examples
!!null null: value for null key
key with null value: !!null null

10.2.1.2. Boolean

   URI:

          tag:yaml.org,2002:bool

   Kind:

          [2227]Scalar.

   Definition:

          [2228]Represents a true/false value. In languages without a
          [2229]native Boolean type (such as C), is usually [2230]bound to
          a native integer type, using one for true and zero for false.

   Canonical Form:

          Either true or false.

   Example 10.5. !!bool Examples
YAML is a superset of JSON: !!bool true
Pluto is a planet: !!bool false

10.2.1.3. Integer

   URI:

          tag:yaml.org,2002:int

   Kind:

          [2231]Scalar.

   Definition:

          [2232]Represents arbitrary sized finite mathematical integers.
          Scalars of this type should be [2233]bound to a [2234]native
          integer data type, if possible.

          Some languages (such as Perl) provide only a “number” type that
          allows for both integer and floating-point values. A YAML
          [2235]processor may use such a type for integers, as long as
          they round-trip properly.

          In some languages (such as C), an integer may overflow the
          [2236]native type’s storage capability. A YAML [2237]processor
          may reject such a value as an error, truncate it with a warning,
          or find some other manner to round-trip it. In general, integers
          representable using 32 binary digits should safely round-trip
          through most systems.

   Canonical Form:

          Decimal integer notation, with a leading “-” character for
          negative values, matching the regular expression
          0 | -? [1-9] [0-9]*

   Example 10.6. !!int Examples
negative: !!int -12
zero: !!int 0
positive: !!int 34

10.2.1.4. Floating Point

   URI:

          tag:yaml.org,2002:float

   Kind:

          [2238]Scalar.

   Definition:

          [2239]Represents an approximation to real numbers, including
          three special values (positive and negative infinity, and “not a
          number”).

          Some languages (such as Perl) provide only a “number” type that
          allows for both integer and floating-point values. A YAML
          [2240]processor may use such a type for floating-point numbers,
          as long as they round-trip properly.

          Not all floating-point values can be stored exactly in any given
          [2241]native type. Hence a float value may change by “a small
          amount” when round-tripped. The supported range and accuracy
          depends on the implementation, though 32 bit IEEE floats should
          be safe. Since YAML does not specify a particular accuracy,
          using floating-point [2242]mapping keys requires great care and
          is not recommended.

   Canonical Form:

          Either 0, .inf, -.inf, .nan, or scientific notation matching the
          regular expression
          -? [1-9] ( \. [0-9]* [1-9] )? ( e [-+] [1-9] [0-9]* )?.

   Example 10.7. !!float Examples
negative: !!float -1
zero: !!float 0
positive: !!float 2.3e4
infinity: !!float .inf
not a number: !!float .nan

10.2.2. Tag Resolution

   The [2243]JSON schema [2244]tag resolution is an extension of the
   [2245]failsafe schema [2246]tag resolution.

   All [2247]nodes with the [2248]“!” non-specific tag are [2249]resolved,
   by the standard [2250]convention, to “tag:yaml.org,2002:seq”,
   “tag:yaml.org,2002:map”, or “tag:yaml.org,2002:str”, according to their
   [2251]kind.

   [2252]Collections with the [2253]“?” non-specific tag (that is,
   [2254]untagged [2255]collections) are [2256]resolved to
   “tag:yaml.org,2002:seq” or “tag:yaml.org,2002:map” according to their
   [2257]kind.

   [2258]Scalars with the [2259]“?” non-specific tag (that is, [2260]plain
   scalars) are matched with a list of regular expressions (first match
   wins, e.g. 0 is resolved as !!int). In principle, JSON files should not
   contain any [2261]scalars that do not match at least one of these.
   Hence the YAML [2262]processor should consider them to be an error.
    Regular expression    Resolved to tag
    null  tag:yaml.org,2002:null
    true | false  tag:yaml.org,2002:bool
    -? ( 0 | [1-9] [0-9]* )  tag:yaml.org,2002:int
    -? ( 0 | [1-9] [0-9]* ) ( \. [0-9]* )? ( [eE] [-+]? [0-9]+ )?
   tag:yaml.org,2002:float
    *  Error

   Example 10.8. JSON Tag Resolution
A null: null
Booleans: [ true, false ]
Integers: [ 0, -0, 3, -19 ]
Floats: [ 0., -0.0, 12e03, -2E+05 ]
Invalid: [ True, Null, 0o7, 0x3A, +12.3 ]

%YAML 1.2
---
!!map {
  !!str "A null" : !!null "null",
  !!str "Booleans: !!seq [
    !!bool "true", !!bool "false"
  ],
  !!str "Integers": !!seq [
    !!int "0", !!int "-0",
    !!int "3", !!int "-19"
  ],
  !!str "Floats": !!seq [
    !!float "0.", !!float "-0.0",
    !!float "12e03", !!float "-2E+05"
  ],
  !!str "Invalid": !!seq [
    # Rejected by the schema
    True, Null, 0o7, 0x3A, +12.3,
  ],
}
...

10.3. Core Schema

   The Core schema is an extension of the [2263]JSON schema, allowing for
   more human-readable [2264]presentation of the same types. This is the
   recommended default [2265]schema that YAML [2266]processor should use
   unless instructed otherwise. It is also strongly recommended that other
   [2267]schemas should be based on it.

10.3.1. Tags

   The core [2268]schema uses the same [2269]tags as the [2270]JSON
   schema.

10.3.2. Tag Resolution

   The [2271]core schema [2272]tag resolution is an extension of the
   [2273]JSON schema [2274]tag resolution.

   All [2275]nodes with the [2276]“!” non-specific tag are [2277]resolved,
   by the standard [2278]convention, to “tag:yaml.org,2002:seq”,
   “tag:yaml.org,2002:map”, or “tag:yaml.org,2002:str”, according to their
   [2279]kind.

   [2280]Collections with the [2281]“?” non-specific tag (that is,
   [2282]untagged [2283]collections) are [2284]resolved to
   “tag:yaml.org,2002:seq” or “tag:yaml.org,2002:map” according to their
   [2285]kind.

   [2286]Scalars with the [2287]“?” non-specific tag (that is, [2288]plain
   scalars) are matched with an extended list of regular expressions.
   However, in this case, if none of the regular expressions matches, the
   [2289]scalar is [2290]resolved to tag:yaml.org,2002:str (that is,
   considered to be a string).
    Regular expression    Resolved to tag
    null | Null | NULL | ~  tag:yaml.org,2002:null
    /* Empty */  tag:yaml.org,2002:null
    true | True | TRUE | false | False | FALSE  tag:yaml.org,2002:bool
    [-+]? [0-9]+  tag:yaml.org,2002:int (Base 10)
    0o [0-7]+  tag:yaml.org,2002:int (Base 8)
    0x [0-9a-fA-F]+  tag:yaml.org,2002:int (Base 16)
    [-+]? ( \. [0-9]+ | [0-9]+ ( \. [0-9]* )? ) ( [eE] [-+]? [0-9]+ )?
   tag:yaml.org,2002:float (Number)
    [-+]? ( \.inf | \.Inf | \.INF )  tag:yaml.org,2002:float (Infinity)
    \.nan | \.NaN | \.NAN  tag:yaml.org,2002:float (Not a number)
    *  tag:yaml.org,2002:str (Default)

   Example 10.9. Core Tag Resolution
A null: null
Also a null: # Empty
Not a null: ""
Booleans: [ true, True, false, FALSE ]
Integers: [ 0, 0o7, 0x3A, -19 ]
Floats: [ 0., -0.0, .5, +12e03, -2E+05 ]
Also floats: [ .inf, -.Inf, +.INF, .NAN ]

%YAML 1.2
---
!!map {
  !!str "A null" : !!null "null",
  !!str "Also a null" : !!null "",
  !!str "Not a null" : !!str "",
  !!str "Booleans: !!seq [
    !!bool "true", !!bool "True",
    !!bool "false", !!bool "FALSE",
  ],
  !!str "Integers": !!seq [
    !!int "0", !!int "0o7",
    !!int "0x3A", !!int "-19",
  ],
  !!str "Floats": !!seq [
    !!float "0.", !!float "-0.0", !!float ".5",
    !!float "+12e03", !!float "-2E+05"
  ],
  !!str "Also floats": !!seq [
    !!float ".inf", !!float "-.Inf",
    !!float "+.INF", !!float ".NAN",
  ],
}
...

10.4. Other Schemas

   None of the above recommended [2291]schemas preclude the use of
   arbitrary explicit [2292]tags. Hence YAML [2293]processors for a
   particular programming language typically provide some form of
   [2294]local tags that map directly to the language’s [2295]native data
   structures (e.g., !ruby/object:Set).

   While such [2296]local tags are useful for ad-hoc [2297]applications,
   they do not suffice for stable, interoperable cross-[2298]application
   or cross-platform data exchange.

   Interoperable [2299]schemas make use of [2300]global tags (URIs) that
   [2301]represent the same data across different programming languages.
   In addition, an interoperable [2302]schema may provide additional
   [2303]tag resolution rules. Such rules may provide additional regular
   expressions, as well as consider the path to the [2304]node. This
   allows interoperable [2305]schemas to use [2306]untagged [2307]nodes.

   It is strongly recommended that such [2308]schemas be based on the
   [2309]core schema defined above. In addition, it is strongly
   recommended that such [2310]schemas make as much use as possible of the
   the YAML tag repository at [2311]http://yaml.org/type/. This repository
   provides recommended [2312]global tags for increasing the portability
   of YAML [2313]documents between different [2314]applications.

   The tag repository is intentionally left out of the scope of this
   specification. This allows it to evolve to better support YAML
   [2315]applications. Hence, developers are encouraged to submit new
   “universal” types to the repository. The yaml-core mailing list at
   [2316]http://lists.sourceforge.net/lists/listinfo/yaml-core is the
   preferred method for such submissions, as well as raising any questions
   regarding this draft.

Index

Indicators

   ! tag indicator, [2317]Tags, [2318]Indicator Characters, [2319]Node
          Tags

        ! local tag, [2320]Tags, [2321]Tag Handles, [2322]Tag Prefixes,
                [2323]Node Tags

        ! non-specific tag, [2324]Resolved Tags, [2325]Node Tags,
                [2326]Tag Resolution, [2327]Tag Resolution, [2328]Tag
                Resolution

        ! primary tag handle, [2329]Tag Handles
        !! secondary tag handle, [2330]Tag Handles
        !…! named handle, [2331]Tag Handles, [2332]Node Tags

   " double-quoted style, [2333]Indicator Characters, [2334]Double-Quoted
          Style

   # comment, [2335]Collections, [2336]Indicator Characters,
          [2337]Comments, [2338]Plain Style, [2339]Block Indentation
          Indicator

   % directive, [2340]Indicator Characters, [2341]Directives,
          [2342]Document Markers, [2343]Bare Documents

   % escaping in URI, [2344]Tags, [2345]Miscellaneous Characters,
          [2346]Node Tags

   & anchor, [2347]Structures, [2348]Indicator Characters, [2349]Node
          Anchors

   ' reserved indicator, [2350]Indicator Characters
   ' single-quoted style, [2351]Indicator Characters, [2352]Single-Quoted
          Style

   * alias, [2353]Structures, [2354]Indicator Characters, [2355]Alias
          Nodes

   + keep chomping, [2356]Block Chomping Indicator
   , end flow entry, [2357]Collections, [2358]Indicator Characters,
          [2359]Miscellaneous Characters, [2360]Node Tags, [2361]Node
          Anchors, [2362]Plain Style, [2363]Flow Collection Styles,
          [2364]Flow Sequences, [2365]Flow Mappings

   - block sequence entry, [2366]Introduction, [2367]Collections,
          [2368]Structures, [2369]Production Parameters, [2370]Indicator
          Characters, [2371]Indentation Spaces, [2372]Plain Style,
          [2373]Block Collection Styles, [2374]Block Sequences,
          [2375]Block Nodes

   - strip chomping, [2376]Block Chomping Indicator
   : mapping value, [2377]Introduction, [2378]Collections,
          [2379]Structures, [2380]Indicator Characters, [2381]Indentation
          Spaces, [2382]Plain Style, [2383]Flow Mappings, [2384]Block
          Mappings

   <…> verbatim tag, [2385]Node Tags
   > folded style, [2386]Scalars, [2387]Indicator Characters, [2388]Folded
          Style

   ? mapping key, [2389]Structures, [2390]Indicator Characters,
          [2391]Indentation Spaces, [2392]Plain Style, [2393]Flow
          Mappings, [2394]Block Mappings

   ? non-specific tag, [2395]Resolved Tags, [2396]Node Tags, [2397]Tag
          Resolution, [2398]Tag Resolution, [2399]Tag Resolution

   @ reserved indicator, [2400]Indicator Characters
   [ start flow sequence, [2401]Collections, [2402]Indicator Characters,
          [2403]Miscellaneous Characters, [2404]Node Tags, [2405]Node
          Anchors, [2406]Plain Style, [2407]Flow Sequences

   \ escaping in double-quoted scalars, [2408]Escaped Characters,
          [2409]Double-Quoted Style

   ] end flow sequence, [2410]Collections, [2411]Indicator Characters,
          [2412]Miscellaneous Characters, [2413]Node Tags, [2414]Node
          Anchors, [2415]Plain Style, [2416]Flow Sequences

   { start flow mapping, [2417]Collections, [2418]Indicator Characters,
          [2419]Miscellaneous Characters, [2420]Node Tags, [2421]Node
          Anchors, [2422]Plain Style, [2423]Flow Mappings

   | literal style, [2424]Scalars, [2425]Indicator Characters,
          [2426]Literal Style

   } end flow mapping, [2427]Collections, [2428]Indicator Characters,
          [2429]Miscellaneous Characters, [2430]Node Tags, [2431]Node
          Anchors, [2432]Plain Style, [2433]Flow Mappings

        prefix, [2434]Document Prefix

A

   alias, [2435]Introduction, [2436]Prior Art, [2437]Structures,
          [2438]Dump, [2439]Serialization Tree, [2440]Anchors and Aliases,
          [2441]Loading Failure Points, [2442]Well-Formed Streams and
          Identified Aliases, [2443]Resolved Tags, [2444]Indicator
          Characters, [2445]Node Anchors, [2446]Flow Styles, [2447]Alias
          Nodes, [2448]Flow Nodes

        identified, [2449]Structures, [2450]Anchors and Aliases,
                [2451]Well-Formed Streams and Identified Aliases

        unidentified, [2452]Loading Failure Points, [2453]Well-Formed
                Streams and Identified Aliases

   anchor, [2454]Structures, [2455]Dump, [2456]Serialization Tree,
          [2457]Anchors and Aliases, [2458]Well-Formed Streams and
          Identified Aliases, [2459]Resolved Tags, [2460]Indicator
          Characters, [2461]Node Properties, [2462]Flow Styles,
          [2463]Alias Nodes, [2464]Flow Nodes

   application, [2465]Introduction, [2466]Prior Art, [2467]Tags,
          [2468]Processing YAML Information, [2469]Dump, [2470]Information
          Models, [2471]Tags, [2472]Serialization Tree, [2473]Keys Order,
          [2474]Resolved Tags, [2475]Available Tags, [2476]Tag Prefixes,
          [2477]Node Tags, [2478]Streams, [2479]Tag Resolution,
          [2480]Other Schemas

B

   block scalar header, [2481]Comments, [2482]Block Scalar Headers,
          [2483]Block Chomping Indicator

   byte order mark, [2484]Character Encodings, [2485]Document Prefix

C

   character encoding, [2486]Character Encodings, [2487]Document Prefix,
          [2488]Streams

        in URI, [2489]Miscellaneous Characters

   chomping, [2490]Production Parameters, [2491]Line Folding, [2492]Block
          Chomping Indicator, [2493]Literal Style, [2494]Folded Style

        clip, [2495]Production Parameters, [2496]Block Chomping Indicator
        keep, [2497]Production Parameters, [2498]Block Chomping Indicator
        strip, [2499]Production Parameters, [2500]Block Chomping Indicator

   collection, [2501]Prior Art, [2502]Representation Graph, [2503]Nodes,
          [2504]Node Comparison, [2505]Anchors and Aliases, [2506]Node
          Styles, [2507]Comments, [2508]Resolved Tags, [2509]Recognized
          and Valid Tags, [2510]Tag Resolution, [2511]Tag Resolution

   comment, [2512]Collections, [2513]Processes, [2514]Dump, [2515]Load,
          [2516]Presentation Stream, [2517]Comments, [2518]Resolved Tags,
          [2519]Indicator Characters, [2520]Comments, [2521]Separation
          Lines, [2522]Plain Style, [2523]Block Scalar Headers,
          [2524]Block Chomping Indicator, [2525]Document Prefix,
          [2526]Streams

   compose, [2527]Processes, [2528]Load, [2529]Keys Order, [2530]Anchors
          and Aliases, [2531]Resolved Tags, [2532]Recognized and Valid
          Tags, [2533]Available Tags, [2534]Node Anchors

   construct, [2535]Processes, [2536]Load, [2537]Serialization Tree,
          [2538]Loading Failure Points, [2539]Recognized and Valid Tags,
          [2540]Available Tags, [2541]Flow Styles, [2542]Generic Mapping,
          [2543]Generic Sequence, [2544]Generic String, [2545]Null,
          [2546]Boolean, [2547]Integer

   content, [2548]Structures, [2549]Dump, [2550]Nodes, [2551]Tags,
          [2552]Node Comparison, [2553]Loading Failure Points,
          [2554]Resolved Tags, [2555]Recognized and Valid Tags,
          [2556]Character Encodings, [2557]Line Break Characters,
          [2558]Escaped Characters, [2559]Indentation Spaces,
          [2560]Separation Spaces, [2561]Line Prefixes, [2562]Empty Lines,
          [2563]Line Folding, [2564]Comments, [2565]Directives, [2566]Tag
          Handles, [2567]Node Properties, [2568]Node Tags, [2569]Node
          Anchors, [2570]Alias Nodes, [2571]Empty Nodes, [2572]Flow Scalar
          Styles, [2573]Double-Quoted Style, [2574]Single-Quoted Style,
          [2575]Plain Style, [2576]Block Scalar Headers, [2577]Block
          Indentation Indicator, [2578]Block Chomping Indicator,
          [2579]Literal Style, [2580]Document Markers, [2581]Bare
          Documents

        valid, [2582]Recognized and Valid Tags

   context, [2583]Production Parameters, [2584]Plain Style

        block-in, [2585]Production Parameters, [2586]Block Nodes
        block-key, [2587]Production Parameters, [2588]Flow Collection
                Styles

        block-out, [2589]Production Parameters, [2590]Block Nodes
        flow-in, [2591]Production Parameters, [2592]Flow Collection Styles

        flow-key, [2593]Production Parameters, [2594]Flow Collection
                Styles

        flow-out, [2595]Production Parameters, [2596]Flow Collection
                Styles

D

   directive, [2597]Structures, [2598]Dump, [2599]Load, [2600]Presentation
          Stream, [2601]Directives, [2602]Indicator Characters,
          [2603]Directives, [2604]Document Markers, [2605]Bare Documents,
          [2606]Explicit Documents, [2607]Directives Documents

        reserved, [2608]Directives, [2609]Directives
        TAG, [2610]Tags, [2611]Directives, [2612]Indicator Characters,
                [2613]Directives, [2614]“TAG” Directives, [2615]Node Tags

        YAML, [2616]Directives, [2617]Directives, [2618]“YAML” Directives

   document, [2619]Prior Art, [2620]Structures, [2621]Presentation Stream,
          [2622]Directives, [2623]Loading Failure Points, [2624]Resolved
          Tags, [2625]Recognized and Valid Tags, [2626]Character
          Encodings, [2627]Line Break Characters, [2628]“YAML” Directives,
          [2629]Tag Prefixes, [2630]Alias Nodes, [2631]Documents,
          [2632]Document Prefix, [2633]Document Markers, [2634]Explicit
          Documents, [2635]Streams, [2636]Failsafe Schema, [2637]Other
          Schemas

        bare, [2638]Bare Documents
        directives, [2639]Directives Documents
        explicit, [2640]Explicit Documents
        suffix, [2641]Document Markers

   dump, [2642]Processes, [2643]Dump

E

   empty line, [2644]Prior Art, [2645]Scalars, [2646]Empty Lines,
          [2647]Line Folding, [2648]Block Indentation Indicator,
          [2649]Block Chomping Indicator, [2650]Literal Style,
          [2651]Folded Style

   equality, [2652]Relation to JSON, [2653]Dump, [2654]Representation
          Graph, [2655]Nodes, [2656]Tags, [2657]Node Comparison,
          [2658]Scalar Formats, [2659]Loading Failure Points,
          [2660]Recognized and Valid Tags

   escaping

        in double-quoted scalars, [2661]Prior Art, [2662]Scalars,
                [2663]Character Set, [2664]Character Encodings,
                [2665]Miscellaneous Characters, [2666]Escaped Characters,
                [2667]Double-Quoted Style

        in single-quoted scalars, [2668]Single-Quoted Style
        in URIs, [2669]Miscellaneous Characters
        non-content line break, [2670]Double-Quoted Style

I

   identity, [2671]Node Comparison
   indicator, [2672]Introduction, [2673]Prior Art, [2674]Collections,
          [2675]Node Styles, [2676]Production Parameters, [2677]Indicator
          Characters, [2678]Line Folding, [2679]Plain Style, [2680]Flow
          Mappings, [2681]Flow Nodes, [2682]Block Styles, [2683]Block
          Scalar Headers, [2684]Block Collection Styles

        indentation, [2685]Block Indentation Indicator
        reserved, [2686]Indicator Characters

   information model, [2687]Information Models
   invalid content, [2688]Loading Failure Points, [2689]Recognized and
          Valid Tags

J

   JSON compatibility, [2690]Character Set, [2691]Character Encodings,
          [2692]Line Break Characters, [2693]Escaped Characters,
          [2694]Comments, [2695]“YAML” Directives, [2696]Flow Mappings,
          [2697]Block Mappings

   JSON-like, [2698]Flow Mappings, [2699]Flow Nodes

K

   key, [2700]Relation to JSON, [2701]Structures, [2702]Dump,
          [2703]Information Models, [2704]Representation Graph,
          [2705]Nodes, [2706]Node Comparison, [2707]Serialization Tree,
          [2708]Keys Order, [2709]Resolved Tags, [2710]Indicator
          Characters, [2711]Flow Mappings, [2712]Block Mappings,
          [2713]Generic Mapping, [2714]Null, [2715]Floating Point

        implicit, [2716]Separation Lines, [2717]Double-Quoted Style,
                [2718]Single-Quoted Style, [2719]Plain Style, [2720]Flow
                Collection Styles, [2721]Flow Mappings, [2722]Block
                Mappings, [2723]Block Nodes

        order, [2724]Processes, [2725]Dump, [2726]Load, [2727]Information
                Models, [2728]Serialization Tree, [2729]Keys Order

   key: value pair, [2730]Introduction, [2731]Collections,
          [2732]Structures, [2733]Nodes, [2734]Keys Order, [2735]Node
          Styles, [2736]Plain Style, [2737]Flow Mappings, [2738]Block
          Collection Styles, [2739]Block Mappings

   kind, [2740]Dump, [2741]Representation Graph, [2742]Nodes, [2743]Tags,
          [2744]Node Comparison, [2745]Node Styles, [2746]Resolved Tags,
          [2747]Node Tags, [2748]Tag Resolution, [2749]Tag Resolution,
          [2750]Tag Resolution

L

   line break, [2751]Prior Art, [2752]Scalars, [2753]Production
          Parameters, [2754]Production Naming Conventions, [2755]Line
          Break Characters, [2756]White Space Characters, [2757]Empty
          Lines, [2758]Line Folding, [2759]Comments, [2760]Double-Quoted
          Style, [2761]Block Scalar Headers, [2762]Block Chomping
          Indicator, [2763]Literal Style, [2764]Folded Style

        non-ASCII, [2765]Line Break Characters, [2766]“YAML” Directives
        normalization, [2767]Line Break Characters, [2768]Literal Style

   line folding, [2769]Prior Art, [2770]Scalars, [2771]Line Folding,
          [2772]Flow Styles, [2773]Double-Quoted Style,
          [2774]Single-Quoted Style, [2775]Plain Style, [2776]Block
          Chomping Indicator, [2777]Folded Style

        block, [2778]Line Folding, [2779]Folded Style
        flow, [2780]Line Folding, [2781]Double-Quoted Style

   line prefix, [2782]Line Prefixes, [2783]Empty Lines
   load, [2784]Processes, [2785]Load, [2786]Loading Failure Points

        failure point, [2787]Load, [2788]Loading Failure Points

M

   mapping, [2789]Introduction, [2790]Prior Art, [2791]Relation to JSON,
          [2792]Collections, [2793]Structures, [2794]Dump,
          [2795]Representation Graph, [2796]Nodes, [2797]Tags, [2798]Node
          Comparison, [2799]Keys Order, [2800]Resolved Tags, [2801]Plain
          Style, [2802]Flow Sequences, [2803]Flow Mappings, [2804]Generic
          Mapping, [2805]Null

   marker, [2806]Presentation Stream, [2807]Document Markers, [2808]Bare
          Documents, [2809]Explicit Documents, [2810]Streams

        directives end, [2811]Structures, [2812]Document Markers,
                [2813]Explicit Documents, [2814]Directives Documents,
                [2815]Streams

        document end, [2816]Structures, [2817]Document Markers,
                [2818]Streams

   more-indented, [2819]Scalars, [2820]Line Folding, [2821]Folded Style

N

   native data structure, [2822]Introduction, [2823]Goals, [2824]Prior
          Art, [2825]Relation to JSON, [2826]Processing YAML Information,
          [2827]Processes, [2828]Dump, [2829]Load, [2830]Representation
          Graph, [2831]Nodes, [2832]Tags, [2833]Node Comparison,
          [2834]Serialization Tree, [2835]Loading Failure Points,
          [2836]Recognized and Valid Tags, [2837]Available Tags,
          [2838]Node Tags, [2839]Flow Styles, [2840]Generic Mapping,
          [2841]Generic Sequence, [2842]Generic String, [2843]Null,
          [2844]Boolean, [2845]Integer, [2846]Floating Point, [2847]Other
          Schemas

   need not, [2848]Terminology
   node, [2849]Structures, [2850]Dump, [2851]Representation Graph,
          [2852]Nodes, [2853]Tags, [2854]Node Comparison,
          [2855]Serialization Tree, [2856]Keys Order, [2857]Anchors and
          Aliases, [2858]Presentation Stream, [2859]Node Styles,
          [2860]Comments, [2861]Loading Failure Points, [2862]Well-Formed
          Streams and Identified Aliases, [2863]Resolved Tags,
          [2864]Recognized and Valid Tags, [2865]Syntax Conventions,
          [2866]Indentation Spaces, [2867]Node Properties, [2868]Node
          Tags, [2869]Node Anchors, [2870]Alias Nodes, [2871]Empty Nodes,
          [2872]Flow Mappings, [2873]Flow Nodes, [2874]Block Indentation
          Indicator, [2875]Block Sequences, [2876]Bare Documents,
          [2877]Tag Resolution, [2878]Tag Resolution, [2879]Tag
          Resolution, [2880]Other Schemas

        completely empty, [2881]Empty Nodes, [2882]Flow Collection Styles,
                [2883]Flow Mappings, [2884]Block Sequences, [2885]Explicit
                Documents

        property, [2886]Node Properties, [2887]Alias Nodes, [2888]Empty
                Nodes, [2889]Flow Mappings, [2890]Flow Nodes, [2891]Block
                Sequences, [2892]Block Mappings, [2893]Block Nodes

        root, [2894]Representation Graph, [2895]Resolved Tags

P

   parse, [2896]Load, [2897]Presentation Stream, [2898]Resolved Tags,
          [2899]Production Parameters, [2900]Line Break Characters,
          [2901]Escaped Characters, [2902]Tag Handles, [2903]Node Tags,
          [2904]Flow Mappings, [2905]Block Mappings, [2906]Block Nodes,
          [2907]Document Markers, [2908]JSON Schema

   present, [2909]Processing YAML Information, [2910]Dump, [2911]Load,
          [2912]Nodes, [2913]Node Comparison, [2914]Presentation Stream,
          [2915]Scalar Formats, [2916]Character Set, [2917]Miscellaneous
          Characters, [2918]Node Tags, [2919]Alias Nodes, [2920]Block
          Mappings, [2921]Core Schema

   presentation, [2922]Processing YAML Information, [2923]Information
          Models, [2924]Presentation Stream, [2925]Production Parameters

        detail, [2926]Dump, [2927]Load, [2928]Information Models,
                [2929]Presentation Stream, [2930]Node Styles, [2931]Scalar
                Formats, [2932]Comments, [2933]Directives, [2934]Resolved
                Tags, [2935]Character Encodings, [2936]Line Break
                Characters, [2937]Escaped Characters, [2938]Indentation
                Spaces, [2939]Separation Spaces, [2940]Line Prefixes,
                [2941]Line Folding, [2942]Comments, [2943]Directives,
                [2944]Tag Handles, [2945]Node Tags, [2946]Flow Scalar
                Styles, [2947]Block Chomping Indicator

   printable character, [2948]Introduction, [2949]Prior Art,
          [2950]Character Set, [2951]White Space Characters, [2952]Escaped
          Characters, [2953]Single-Quoted Style, [2954]Literal Style

   processor, [2955]Terminology, [2956]Processing YAML Information,
          [2957]Dump, [2958]Node Comparison, [2959]Presentation Stream,
          [2960]Directives, [2961]Well-Formed Streams and Identified
          Aliases, [2962]Resolved Tags, [2963]Recognized and Valid Tags,
          [2964]Available Tags, [2965]Character Set, [2966]Character
          Encodings, [2967]Line Break Characters, [2968]Miscellaneous
          Characters, [2969]Comments, [2970]Directives, [2971]“YAML”
          Directives, [2972]Tag Handles, [2973]Node Tags, [2974]Node
          Anchors, [2975]Flow Mappings, [2976]Block Indentation Indicator,
          [2977]Failsafe Schema, [2978]JSON Schema, [2979]Integer,
          [2980]Floating Point, [2981]Tag Resolution, [2982]Core Schema,
          [2983]Other Schemas

R

   represent, [2984]Introduction, [2985]Prior Art, [2986]Dump, [2987]Tags,
          [2988]Node Comparison, [2989]Keys Order, [2990]Generic Mapping,
          [2991]Generic Sequence, [2992]Generic String, [2993]Null,
          [2994]Boolean, [2995]Integer, [2996]Floating Point, [2997]Other
          Schemas

   representation, [2998]Processing YAML Information, [2999]Processes,
          [3000]Dump, [3001]Load, [3002]Information Models,
          [3003]Representation Graph, [3004]Nodes, [3005]Node Comparison,
          [3006]Serialization Tree, [3007]Keys Order, [3008]Anchors and
          Aliases, [3009]Presentation Stream, [3010]Node Styles,
          [3011]Scalar Formats, [3012]Comments, [3013]Directives,
          [3014]Available Tags, [3015]Node Anchors

        complete, [3016]Loading Failure Points, [3017]Resolved Tags,
                [3018]Recognized and Valid Tags, [3019]Available Tags

        partial, [3020]Loading Failure Points, [3021]Resolved Tags,
                [3022]Recognized and Valid Tags, [3023]Tag Resolution

   required, [3024]Terminology

S

   scalar, [3025]Introduction, [3026]Prior Art, [3027]Scalars, [3028]Dump,
          [3029]Representation Graph, [3030]Nodes, [3031]Tags, [3032]Node
          Comparison, [3033]Scalar Formats, [3034]Comments,
          [3035]Recognized and Valid Tags, [3036]Line Break Characters,
          [3037]Separation Spaces, [3038]Line Prefixes, [3039]Comments,
          [3040]Empty Nodes, [3041]Block Chomping Indicator, [3042]Generic
          Mapping, [3043]Generic String, [3044]Null, [3045]Boolean,
          [3046]Integer, [3047]Floating Point, [3048]Tag Resolution,
          [3049]Tag Resolution

        canonical form, [3050]Prior Art, [3051]Tags, [3052]Node
                Comparison, [3053]Scalar Formats, [3054]Loading Failure
                Points

        content format, [3055]Dump, [3056]Load, [3057]Tags, [3058]Node
                Comparison, [3059]Presentation Stream, [3060]Scalar
                Formats, [3061]Loading Failure Points

   schema, [3062]Recommended Schemas, [3063]Failsafe Schema, [3064]JSON
          Schema, [3065]Tags, [3066]Core Schema, [3067]Tags, [3068]Other
          Schemas

        core, [3069]Core Schema, [3070]Tag Resolution, [3071]Other Schemas

        failsafe, [3072]Tags, [3073]Failsafe Schema, [3074]Tags, [3075]Tag
                Resolution

        JSON, [3076]Tags, [3077]JSON Schema, [3078]Tag Resolution,
                [3079]Core Schema, [3080]Tags, [3081]Tag Resolution

   sequence, [3082]Introduction, [3083]Prior Art, [3084]Dump,
          [3085]Representation Graph, [3086]Nodes, [3087]Tags, [3088]Node
          Comparison, [3089]Keys Order, [3090]Resolved Tags, [3091]Flow
          Mappings, [3092]Generic Sequence

   serialization, [3093]Processing YAML Information, [3094]Processes,
          [3095]Dump, [3096]Load, [3097]Information Models,
          [3098]Serialization Tree, [3099]Anchors and Aliases,
          [3100]Presentation Stream, [3101]Node Styles, [3102]Scalar
          Formats, [3103]Comments, [3104]Directives, [3105]Node Anchors

        detail, [3106]Dump, [3107]Load, [3108]Information Models,
                [3109]Keys Order, [3110]Anchors and Aliases, [3111]Node
                Anchors

   serialize, [3112]Introduction, [3113]Prior Art, [3114]Relation to JSON,
          [3115]Dump, [3116]Load, [3117]Keys Order, [3118]Anchors and
          Aliases, [3119]Alias Nodes

   shall, [3120]Terminology
   space, [3121]Prior Art, [3122]Scalars, [3123]White Space Characters,
          [3124]Indentation Spaces, [3125]Line Folding,
          [3126]Single-Quoted Style, [3127]Plain Style, [3128]Block
          Indentation Indicator, [3129]Folded Style, [3130]Block
          Sequences, [3131]Block Nodes, [3132]Bare Documents

        indentation, [3133]Introduction, [3134]Prior Art,
                [3135]Collections, [3136]Dump, [3137]Load,
                [3138]Information Models, [3139]Node Styles,
                [3140]Resolved Tags, [3141]Production Parameters,
                [3142]Production Naming Conventions, [3143]Indentation
                Spaces, [3144]Separation Spaces, [3145]Line Prefixes,
                [3146]Line Folding, [3147]Comments, [3148]Separation
                Lines, [3149]Directives, [3150]Block Styles, [3151]Block
                Indentation Indicator, [3152]Block Chomping Indicator,
                [3153]Literal Style, [3154]Block Sequences, [3155]Block
                Nodes, [3156]Bare Documents

        separation, [3157]Separation Spaces, [3158]Comments, [3159]Flow
                Mappings, [3160]Block Sequences

        white, [3161]Production Naming Conventions, [3162]White Space
                Characters, [3163]Separation Spaces, [3164]Line Prefixes,
                [3165]Line Folding, [3166]Comments, [3167]Double-Quoted
                Style, [3168]Single-Quoted Style, [3169]Plain Style,
                [3170]Flow Mappings, [3171]Literal Style, [3172]Folded
                Style, [3173]Block Sequences

   stream, [3174]Prior Art, [3175]Processing YAML Information,
          [3176]Processes, [3177]Dump, [3178]Load, [3179]Presentation
          Stream, [3180]Loading Failure Points, [3181]Well-Formed Streams
          and Identified Aliases, [3182]Resolved Tags, [3183]Syntax
          Conventions, [3184]Character Set, [3185]Character Encodings,
          [3186]Miscellaneous Characters, [3187]Comments, [3188]Tag
          Prefixes, [3189]Empty Nodes, [3190]Documents, [3191]Streams

        ill-formed, [3192]Load, [3193]Loading Failure Points,
                [3194]Well-Formed Streams and Identified Aliases

        well-formed, [3195]Well-Formed Streams and Identified Aliases,
                [3196]Streams

   style, [3197]Dump, [3198]Load, [3199]Information Models,
          [3200]Presentation Stream, [3201]Node Styles, [3202]Scalar
          Formats, [3203]Resolved Tags, [3204]Node Tags,
          [3205]Double-Quoted Style, [3206]Plain Style

        block, [3207]Prior Art, [3208]Scalars, [3209]Node Styles,
                [3210]Production Parameters, [3211]Indentation Spaces,
                [3212]Block Styles, [3213]Block Sequences

              collection, [3214]Collections, [3215]Structures,
                      [3216]Indentation Spaces, [3217]Flow Collection
                      Styles, [3218]Block Collection Styles, [3219]Block
                      Sequences, [3220]Block Nodes

              folded, [3221]Scalars, [3222]Node Styles, [3223]Indicator
                      Characters, [3224]Line Folding, [3225]Block Scalar
                      Styles, [3226]Literal Style, [3227]Folded Style

              literal, [3228]Prior Art, [3229]Scalars, [3230]Node Styles,
                      [3231]Indicator Characters, [3232]Block Scalar
                      Styles, [3233]Literal Style, [3234]Folded Style

              mapping, [3235]Node Styles, [3236]Production Parameters,
                      [3237]Block Mappings, [3238]Block Nodes

              scalar, [3239]Node Styles, [3240]Block Scalar Styles,
                      [3241]Block Scalar Headers, [3242]Block Indentation
                      Indicator, [3243]Block Chomping Indicator

              sequence, [3244]Collections, [3245]Node Styles,
                      [3246]Production Parameters, [3247]Indicator
                      Characters, [3248]Block Sequences, [3249]Block
                      Mappings, [3250]Block Nodes

        compact block collection, [3251]Node Styles, [3252]Block
                Sequences, [3253]Block Mappings

        flow, [3254]Prior Art, [3255]Collections, [3256]Scalars,
                [3257]Node Styles, [3258]Production Parameters, [3259]Line
                Folding, [3260]Flow Styles, [3261]Flow Sequences,
                [3262]Flow Nodes, [3263]Block Nodes

              collection, [3264]Syntax Conventions, [3265]Production
                      Parameters, [3266]Indicator Characters,
                      [3267]Miscellaneous Characters, [3268]Node Tags,
                      [3269]Node Anchors, [3270]Plain Style, [3271]Flow
                      Collection Styles

              double-quoted, [3272]Prior Art, [3273]Scalars, [3274]Node
                      Styles, [3275]Syntax Conventions, [3276]Character
                      Set, [3277]Character Encodings, [3278]Indicator
                      Characters, [3279]Escaped Characters, [3280]Flow
                      Scalar Styles, [3281]Double-Quoted Style, [3282]Flow
                      Nodes

              mapping, [3283]Collections, [3284]Node Styles,
                      [3285]Production Parameters, [3286]Indicator
                      Characters, [3287]Flow Mappings, [3288]Block
                      Mappings

              plain, [3289]Scalars, [3290]Node Styles, [3291]Resolved
                      Tags, [3292]Production Parameters, [3293]Indicator
                      Characters, [3294]Node Tags, [3295]Empty Nodes,
                      [3296]Flow Scalar Styles, [3297]Plain Style,
                      [3298]Flow Mappings, [3299]Flow Nodes, [3300]Block
                      Collection Styles, [3301]Block Sequences,
                      [3302]Block Mappings, [3303]Block Nodes,
                      [3304]Document Markers, [3305]Tag Resolution,
                      [3306]Tag Resolution

              scalar, [3307]Scalars, [3308]Node Styles, [3309]Line
                      Prefixes, [3310]Line Folding, [3311]Flow Scalar
                      Styles

              sequence, [3312]Collections, [3313]Node Styles,
                      [3314]Indicator Characters, [3315]Flow Sequences,
                      [3316]Flow Mappings

              single-quoted, [3317]Node Styles, [3318]Production
                      Parameters, [3319]Indicator Characters, [3320]Flow
                      Scalar Styles, [3321]Single-Quoted Style

        scalar, [3322]Node Styles, [3323]Escaped Characters, [3324]Empty
                Lines, [3325]Flow Scalar Styles, [3326]Literal Style

        single key:value pair mapping, [3327]Keys Order, [3328]Node
                Styles, [3329]Flow Sequences, [3330]Flow Mappings,
                [3331]Block Mappings

T

   tab, [3332]Prior Art, [3333]Character Set, [3334]White Space
          Characters, [3335]Indentation Spaces, [3336]Separation Spaces,
          [3337]Line Prefixes, [3338]Block Indentation Indicator

   tag, [3339]Prior Art, [3340]Tags, [3341]Dump, [3342]Representation
          Graph, [3343]Nodes, [3344]Tags, [3345]Node Comparison,
          [3346]Scalar Formats, [3347]Loading Failure Points,
          [3348]Resolved Tags, [3349]Recognized and Valid Tags,
          [3350]Available Tags, [3351]Syntax Conventions, [3352]Production
          Parameters, [3353]Indicator Characters, [3354]Miscellaneous
          Characters, [3355]“TAG” Directives, [3356]Tag Prefixes,
          [3357]Node Properties, [3358]Node Tags, [3359]Flow Styles,
          [3360]Recommended Schemas, [3361]Tags, [3362]Tags, [3363]Other
          Schemas

        available, [3364]Available Tags
        global, [3365]Prior Art, [3366]Tags, [3367]Dump, [3368]Tags,
                [3369]Resolved Tags, [3370]Tag Handles, [3371]Tag
                Prefixes, [3372]Node Tags, [3373]Other Schemas

        handle, [3374]Tags, [3375]Processes, [3376]Dump, [3377]Indicator
                Characters, [3378]“TAG” Directives, [3379]Tag Handles,
                [3380]Tag Prefixes, [3381]Node Tags

              named, [3382]Miscellaneous Characters, [3383]Tag Handles,
                      [3384]Node Tags

              primary, [3385]Tag Handles
              secondary, [3386]Tag Handles

        local, [3387]Prior Art, [3388]Tags, [3389]Dump, [3390]Tags,
                [3391]Resolved Tags, [3392]Indicator Characters, [3393]Tag
                Handles, [3394]Tag Prefixes, [3395]Node Tags, [3396]Other
                Schemas

        non-specific, [3397]Tags, [3398]Dump, [3399]Loading Failure
                Points, [3400]Resolved Tags, [3401]Indicator Characters,
                [3402]Node Tags, [3403]Recommended Schemas, [3404]Tag
                Resolution, [3405]Tag Resolution, [3406]Other Schemas

        prefix, [3407]“TAG” Directives, [3408]Tag Prefixes, [3409]Node
                Tags

        property, [3410]Resolved Tags, [3411]Indicator Characters,
                [3412]Node Tags

        recognized, [3413]Recognized and Valid Tags
        repository, [3414]Tags, [3415]Tag Handles, [3416]Other Schemas

              bool, [3417]Boolean
              float, [3418]Tags, [3419]Floating Point
              int, [3420]Tags, [3421]Integer
              map, [3422]Tags, [3423]Generic Mapping
              null, [3424]Tags, [3425]Empty Nodes, [3426]Null
              seq, [3427]Tags, [3428]Generic Sequence
              str, [3429]Tags, [3430]Generic String

        resolution, [3431]Tags, [3432]Loading Failure Points,
                [3433]Resolved Tags, [3434]Node Tags, [3435]Flow Scalar
                Styles, [3436]Recommended Schemas, [3437]Tag Resolution,
                [3438]Tag Resolution, [3439]Tag Resolution, [3440]Other
                Schemas

              convention, [3441]Resolved Tags, [3442]Node Tags, [3443]Tag
                      Resolution, [3444]Tag Resolution, [3445]Tag
                      Resolution

        shorthand, [3446]Tags, [3447]Miscellaneous Characters, [3448]“TAG”
                Directives, [3449]Tag Handles, [3450]Tag Prefixes,
                [3451]Node Tags

        specific, [3452]Resolved Tags, [3453]Node Tags
        unavailable, [3454]Load, [3455]Loading Failure Points,
                [3456]Available Tags

        unrecognized, [3457]Loading Failure Points, [3458]Recognized and
                Valid Tags

        unresolved, [3459]Loading Failure Points, [3460]Resolved Tags
        verbatim, [3461]Node Tags

   trimming, [3462]Line Folding

V

   value, [3463]Dump, [3464]Nodes, [3465]Node Comparison, [3466]Resolved
          Tags, [3467]Indicator Characters, [3468]Flow Mappings,
          [3469]Block Mappings, [3470]Generic Mapping, [3471]Null

Y

   YAML 1.1 processing, [3472]Line Break Characters, [3473]“YAML”
          Directives

References

   1. mailto:oren@ben-kiki.org
   2. mailto:cce@clarkevans.com
   3. mailto:ingy@ingy.net
   4. https://yaml.org/spec/1.2/spec.html
   5. https://yaml.org/spec/1.2/spec.pdf
   6. https://yaml.org/spec/1.2/spec.ps
   7. https://yaml.org/spec/1.2/errata.html
   8. https://yaml.org/spec/1.2/2009-07-21/spec.html
   9. http://lists.sourceforge.net/lists/listinfo/yaml-core
  10. https://yaml.org/spec/1.2/errata.html
  11. https://yaml.org/spec/1.2/spec.html
  12. http://www.unicode.org/
  13. https://yaml.org/spec/1.2/spec.html#Introduction
  14. https://yaml.org/spec/1.2/spec.html#id2708649
  15. https://yaml.org/spec/1.2/spec.html#id2708710
  16. https://yaml.org/spec/1.2/spec.html#id2759572
  17. https://yaml.org/spec/1.2/spec.html#id2759732
  18. https://yaml.org/spec/1.2/spec.html#id2759768
  19. https://yaml.org/spec/1.2/spec.html#Preview
  20. https://yaml.org/spec/1.2/spec.html#id2759963
  21. https://yaml.org/spec/1.2/spec.html#id2760395
  22. https://yaml.org/spec/1.2/spec.html#id2760844
  23. https://yaml.org/spec/1.2/spec.html#id2761292
  24. https://yaml.org/spec/1.2/spec.html#id2761803
  25. https://yaml.org/spec/1.2/spec.html#Processing
  26. https://yaml.org/spec/1.2/spec.html#id2762107
  27. https://yaml.org/spec/1.2/spec.html#id2762313
  28. https://yaml.org/spec/1.2/spec.html#id2763035
  29. https://yaml.org/spec/1.2/spec.html#id2763452
  30. https://yaml.org/spec/1.2/spec.html#id2763754
  31. https://yaml.org/spec/1.2/spec.html#id2764044
  32. https://yaml.org/spec/1.2/spec.html#id2764295
  33. https://yaml.org/spec/1.2/spec.html#id2764652
  34. https://yaml.org/spec/1.2/spec.html#id2765410
  35. https://yaml.org/spec/1.2/spec.html#id2765608
  36. https://yaml.org/spec/1.2/spec.html#id2765878
  37. https://yaml.org/spec/1.2/spec.html#id2766150
  38. https://yaml.org/spec/1.2/spec.html#id2766446
  39. https://yaml.org/spec/1.2/spec.html#id2766934
  40. https://yaml.org/spec/1.2/spec.html#id2767100
  41. https://yaml.org/spec/1.2/spec.html#id2767222
  42. https://yaml.org/spec/1.2/spec.html#id2767381
  43. https://yaml.org/spec/1.2/spec.html#id2767852
  44. https://yaml.org/spec/1.2/spec.html#id2768011
  45. https://yaml.org/spec/1.2/spec.html#id2769212
  46. https://yaml.org/spec/1.2/spec.html#id2769542
  47. https://yaml.org/spec/1.2/spec.html#Syntax
  48. https://yaml.org/spec/1.2/spec.html#id2769866
  49. https://yaml.org/spec/1.2/spec.html#id2770517
  50. https://yaml.org/spec/1.2/spec.html#Characters
  51. https://yaml.org/spec/1.2/spec.html#id2770814
  52. https://yaml.org/spec/1.2/spec.html#id2771184
  53. https://yaml.org/spec/1.2/spec.html#id2772075
  54. https://yaml.org/spec/1.2/spec.html#id2774608
  55. https://yaml.org/spec/1.2/spec.html#id2775170
  56. https://yaml.org/spec/1.2/spec.html#id2775468
  57. https://yaml.org/spec/1.2/spec.html#id2776092
  58. https://yaml.org/spec/1.2/spec.html#Basic
  59. https://yaml.org/spec/1.2/spec.html#id2777534
  60. https://yaml.org/spec/1.2/spec.html#id2778241
  61. https://yaml.org/spec/1.2/spec.html#id2778481
  62. https://yaml.org/spec/1.2/spec.html#id2778853
  63. https://yaml.org/spec/1.2/spec.html#id2779048
  64. https://yaml.org/spec/1.2/spec.html#id2780069
  65. https://yaml.org/spec/1.2/spec.html#id2780810
  66. https://yaml.org/spec/1.2/spec.html#id2781147
  67. https://yaml.org/spec/1.2/spec.html#id2781553
  68. https://yaml.org/spec/1.2/spec.html#id2782090
  69. https://yaml.org/spec/1.2/spec.html#id2782457
  70. https://yaml.org/spec/1.2/spec.html#id2783273
  71. https://yaml.org/spec/1.2/spec.html#id2783797
  72. https://yaml.org/spec/1.2/spec.html#id2784064
  73. https://yaml.org/spec/1.2/spec.html#id2785586
  74. https://yaml.org/spec/1.2/spec.html#Flow
  75. https://yaml.org/spec/1.2/spec.html#id2786196
  76. https://yaml.org/spec/1.2/spec.html#id2786563
  77. https://yaml.org/spec/1.2/spec.html#id2786942
  78. https://yaml.org/spec/1.2/spec.html#id2787109
  79. https://yaml.org/spec/1.2/spec.html#id2788097
  80. https://yaml.org/spec/1.2/spec.html#id2788859
  81. https://yaml.org/spec/1.2/spec.html#id2790088
  82. https://yaml.org/spec/1.2/spec.html#id2790320
  83. https://yaml.org/spec/1.2/spec.html#id2790832
  84. https://yaml.org/spec/1.2/spec.html#id2792977
  85. https://yaml.org/spec/1.2/spec.html#Block
  86. https://yaml.org/spec/1.2/spec.html#id2793652
  87. https://yaml.org/spec/1.2/spec.html#id2793718
  88. https://yaml.org/spec/1.2/spec.html#id2793979
  89. https://yaml.org/spec/1.2/spec.html#id2794534
  90. https://yaml.org/spec/1.2/spec.html#id2795688
  91. https://yaml.org/spec/1.2/spec.html#id2796251
  92. https://yaml.org/spec/1.2/spec.html#id2797293
  93. https://yaml.org/spec/1.2/spec.html#id2797382
  94. https://yaml.org/spec/1.2/spec.html#id2798057
  95. https://yaml.org/spec/1.2/spec.html#id2799181
  96. https://yaml.org/spec/1.2/spec.html#YAML
  97. https://yaml.org/spec/1.2/spec.html#id2800132
  98. https://yaml.org/spec/1.2/spec.html#id2800168
  99. https://yaml.org/spec/1.2/spec.html#id2800401
 100. https://yaml.org/spec/1.2/spec.html#id2800967
 101. https://yaml.org/spec/1.2/spec.html#id2801301
 102. https://yaml.org/spec/1.2/spec.html#id2801522
 103. https://yaml.org/spec/1.2/spec.html#id2801681
 104. https://yaml.org/spec/1.2/spec.html#Schema
 105. https://yaml.org/spec/1.2/spec.html#id2802346
 106. https://yaml.org/spec/1.2/spec.html#id2802427
 107. https://yaml.org/spec/1.2/spec.html#id2802432
 108. https://yaml.org/spec/1.2/spec.html#id2802662
 109. https://yaml.org/spec/1.2/spec.html#id2802842
 110. https://yaml.org/spec/1.2/spec.html#id2803036
 111. https://yaml.org/spec/1.2/spec.html#id2803231
 112. https://yaml.org/spec/1.2/spec.html#id2803311
 113. https://yaml.org/spec/1.2/spec.html#id2803362
 114. https://yaml.org/spec/1.2/spec.html#id2803629
 115. https://yaml.org/spec/1.2/spec.html#id2803828
 116. https://yaml.org/spec/1.2/spec.html#id2804092
 117. https://yaml.org/spec/1.2/spec.html#id2804356
 118. https://yaml.org/spec/1.2/spec.html#id2804923
 119. https://yaml.org/spec/1.2/spec.html#id2805019
 120. https://yaml.org/spec/1.2/spec.html#id2805071
 121. https://yaml.org/spec/1.2/spec.html#id2805770
 122. https://yaml.org/spec/1.2/spec.html#id2806177
 123. https://yaml.org/spec/1.2/spec.html#application//
 124. https://yaml.org/spec/1.2/spec.html#printable character//
 125. https://yaml.org/spec/1.2/spec.html#indicator//
 126. https://yaml.org/spec/1.2/spec.html#space/indentation/
 127. https://yaml.org/spec/1.2/spec.html#: mapping value//
 128. https://yaml.org/spec/1.2/spec.html#key: value pair//
 129. https://yaml.org/spec/1.2/spec.html#- block sequence entry//
 130. https://yaml.org/spec/1.2/spec.html#sequence//
 131. https://yaml.org/spec/1.2/spec.html#native data structure//
 132. https://yaml.org/spec/1.2/spec.html#represent//
 133. https://yaml.org/spec/1.2/spec.html#mapping//
 134. https://yaml.org/spec/1.2/spec.html#sequence//
 135. https://yaml.org/spec/1.2/spec.html#scalar//
 136. https://yaml.org/spec/1.2/spec.html#alias//
 137. https://yaml.org/spec/1.2/spec.html#serialize//
 138. https://yaml.org/spec/1.2/spec.html#native data structure//
 139. https://yaml.org/spec/1.2/spec.html#native data structure//
 140. http://www.docuverse.com/smldev/
 141. http://search.cpan.org/dist/Data-Denter/
 142. http://cm.bell-labs.com/cm/cs/cbook/index.html
 143. http://java.sun.com/
 144. http://www.perl.org/
 145. http://www.python.org/
 146. http://www.ruby-lang.org/
 147. http://www.ietf.org/rfc/rfc0822.txt
 148. http://www.ics.uci.edu/pub/ietf/html/rfc1866.txt
 149. http://www.ietf.org/rfc/rfc2045.txt
 150. http://www.ietf.org/rfc/rfc2396.txt
 151. http://www.w3.org/TR/REC-xml.html
 152. http://www.saxproject.org/
 153. http://www.w3.org/TR/SOAP
 154. http://www.json.org/
 155. https://yaml.org/spec/1.2/spec.html#stream//
 156. https://yaml.org/spec/1.2/spec.html#document//
 157. https://yaml.org/spec/1.2/spec.html#space/indentation/
 158. https://yaml.org/spec/1.2/spec.html#tab//
 159. https://yaml.org/spec/1.2/spec.html#style/block/
 160. https://yaml.org/spec/1.2/spec.html#style/block/literal
 161. https://yaml.org/spec/1.2/spec.html#space/indentation/
 162. https://yaml.org/spec/1.2/spec.html#escaping/in double-quoted scalars/
 163. https://yaml.org/spec/1.2/spec.html#indicator//
 164. https://yaml.org/spec/1.2/spec.html#style/flow/
 165. https://yaml.org/spec/1.2/spec.html#style/block/
 166. https://yaml.org/spec/1.2/spec.html#style/flow/double-quoted
 167. https://yaml.org/spec/1.2/spec.html#escaping/in double-quoted scalars/
 168. https://yaml.org/spec/1.2/spec.html#printable character//
 169. https://yaml.org/spec/1.2/spec.html#ns-esc-8-bit
 170. https://yaml.org/spec/1.2/spec.html#printable character//
 171. https://yaml.org/spec/1.2/spec.html#escaping/in double-quoted scalars/
 172. https://yaml.org/spec/1.2/spec.html#ns-esc-16-bit
 173. https://yaml.org/spec/1.2/spec.html#ns-esc-32-bit
 174. https://yaml.org/spec/1.2/spec.html#line folding//
 175. https://yaml.org/spec/1.2/spec.html#line break//
 176. https://yaml.org/spec/1.2/spec.html#line break//
 177. https://yaml.org/spec/1.2/spec.html#line folding//
 178. https://yaml.org/spec/1.2/spec.html#space//
 179. https://yaml.org/spec/1.2/spec.html#empty line//
 180. https://yaml.org/spec/1.2/spec.html#line break//
 181. https://yaml.org/spec/1.2/spec.html#scalar/canonical form/
 182. https://yaml.org/spec/1.2/spec.html#scalar//
 183. https://yaml.org/spec/1.2/spec.html#collection//
 184. https://yaml.org/spec/1.2/spec.html#mapping//
 185. https://yaml.org/spec/1.2/spec.html#sequence//
 186. https://yaml.org/spec/1.2/spec.html#scalar//
 187. https://yaml.org/spec/1.2/spec.html#native data structure//
 188. https://yaml.org/spec/1.2/spec.html#serialize//
 189. https://yaml.org/spec/1.2/spec.html#native data structure//
 190. https://yaml.org/spec/1.2/spec.html#alias//
 191. https://yaml.org/spec/1.2/spec.html#application//
 192. https://yaml.org/spec/1.2/spec.html#tag//
 193. https://yaml.org/spec/1.2/spec.html#represent//
 194. https://yaml.org/spec/1.2/spec.html#tag/global/
 195. https://yaml.org/spec/1.2/spec.html#tag/local/
 196. https://yaml.org/spec/1.2/spec.html#application//
 197. https://yaml.org/spec/1.2/spec.html#document//
 198. https://yaml.org/spec/1.2/spec.html#stream//
 199. https://yaml.org/spec/1.2/spec.html#serialize//
 200. https://yaml.org/spec/1.2/spec.html#native data structure//
 201. http://www.ietf.org/rfc/rfc4627.txt
 202. https://yaml.org/spec/1.2/spec.html#mapping//
 203. https://yaml.org/spec/1.2/spec.html#key//
 204. https://yaml.org/spec/1.2/spec.html#equality//
 205. https://yaml.org/spec/1.2/spec.html#serialize//
 206. https://yaml.org/spec/1.2/spec.html#native data structure//
 207. https://yaml.org/xml
 208. http://www.ietf.org/rfc/rfc2119.txt
 209. https://yaml.org/spec/1.2/spec.html#processor//
 210. https://yaml.org/spec/1.2/spec.html#processor//
 211. https://yaml.org/spec/1.2/spec.html#processor//
 212. https://yaml.org/spec/1.2/spec.html#Preview
 213. https://yaml.org/spec/1.2/spec.html#Processing
 214. https://yaml.org/spec/1.2/spec.html#Syntax
 215. https://yaml.org/spec/1.2/spec.html#YAML
 216. https://yaml.org/spec/1.2/spec.html#Syntax
 217. https://yaml.org/spec/1.2/spec.html#style/block/collection
 218. https://yaml.org/spec/1.2/spec.html#space/indentation/
 219. https://yaml.org/spec/1.2/spec.html#style/block/sequence
 220. https://yaml.org/spec/1.2/spec.html#- block sequence entry//
 221. https://yaml.org/spec/1.2/spec.html#mapping//
 222. https://yaml.org/spec/1.2/spec.html#: mapping value//
 223. https://yaml.org/spec/1.2/spec.html#key: value pair//
 224. https://yaml.org/spec/1.2/spec.html#comment//
 225. https://yaml.org/spec/1.2/spec.html## comment//
 226. https://yaml.org/spec/1.2/spec.html#style/flow/
 227. https://yaml.org/spec/1.2/spec.html#indicator//
 228. https://yaml.org/spec/1.2/spec.html#space/indentation/
 229. https://yaml.org/spec/1.2/spec.html#style/flow/sequence
 230. https://yaml.org/spec/1.2/spec.html#, end flow entry//
 231. https://yaml.org/spec/1.2/spec.html#[ start flow sequence//
 232. https://yaml.org/spec/1.2/spec.html#] end flow sequence//
 233. https://yaml.org/spec/1.2/spec.html#style/flow/mapping
 234. https://yaml.org/spec/1.2/spec.html#{ start flow mapping//
 235. https://yaml.org/spec/1.2/spec.html#} end flow mapping//
 236. https://yaml.org/spec/1.2/spec.html#marker/directives end/
 237. https://yaml.org/spec/1.2/spec.html#directive//
 238. https://yaml.org/spec/1.2/spec.html#document//
 239. https://yaml.org/spec/1.2/spec.html#content//
 240. https://yaml.org/spec/1.2/spec.html#directive//
 241. https://yaml.org/spec/1.2/spec.html#marker/document end/
 242. https://yaml.org/spec/1.2/spec.html#node//
 243. https://yaml.org/spec/1.2/spec.html#alias/identified/
 244. https://yaml.org/spec/1.2/spec.html#anchor//
 245. https://yaml.org/spec/1.2/spec.html#& anchor//
 246. https://yaml.org/spec/1.2/spec.html#alias//
 247. https://yaml.org/spec/1.2/spec.html#* alias//
 248. https://yaml.org/spec/1.2/spec.html#? mapping key//
 249. https://yaml.org/spec/1.2/spec.html#mapping//
 250. https://yaml.org/spec/1.2/spec.html#key//
 251. https://yaml.org/spec/1.2/spec.html#style/block/collection
 252. https://yaml.org/spec/1.2/spec.html#key: value pair//
 253. https://yaml.org/spec/1.2/spec.html#- block sequence entry//
 254. https://yaml.org/spec/1.2/spec.html#: mapping value//
 255. https://yaml.org/spec/1.2/spec.html#? mapping key//
 256. https://yaml.org/spec/1.2/spec.html#scalar//
 257. https://yaml.org/spec/1.2/spec.html#style/block/
 258. https://yaml.org/spec/1.2/spec.html#style/block/literal
 259. https://yaml.org/spec/1.2/spec.html#| literal style//
 260. https://yaml.org/spec/1.2/spec.html#line break//
 261. https://yaml.org/spec/1.2/spec.html#style/block/folded
 262. https://yaml.org/spec/1.2/spec.html#> folded style//
 263. https://yaml.org/spec/1.2/spec.html#line break//
 264. https://yaml.org/spec/1.2/spec.html#line folding//
 265. https://yaml.org/spec/1.2/spec.html#space//
 266. https://yaml.org/spec/1.2/spec.html#empty line//
 267. https://yaml.org/spec/1.2/spec.html#more-indented//
 268. https://yaml.org/spec/1.2/spec.html#style/flow/scalar
 269. https://yaml.org/spec/1.2/spec.html#style/flow/plain
 270. https://yaml.org/spec/1.2/spec.html#style/flow/double-quoted
 271. https://yaml.org/spec/1.2/spec.html#escaping/in double-quoted scalars/
 272. https://yaml.org/spec/1.2/spec.html#style/flow/
 273. https://yaml.org/spec/1.2/spec.html#escaping/in double-quoted scalars/
 274. https://yaml.org/spec/1.2/spec.html#style/flow/scalar
 275. https://yaml.org/spec/1.2/spec.html#line break//
 276. https://yaml.org/spec/1.2/spec.html#line folding//
 277. https://yaml.org/spec/1.2/spec.html#tag/non-specific/
 278. https://yaml.org/spec/1.2/spec.html#application//
 279. https://yaml.org/spec/1.2/spec.html#tag/repository/seq
 280. https://yaml.org/spec/1.2/spec.html#tag/repository/map
 281. https://yaml.org/spec/1.2/spec.html#tag/repository/str
 282. https://yaml.org/spec/1.2/spec.html#schema/failsafe/
 283. https://yaml.org/spec/1.2/spec.html#tag/repository/int
 284. https://yaml.org/spec/1.2/spec.html#tag/repository/float
 285. https://yaml.org/spec/1.2/spec.html#tag/repository/null
 286. https://yaml.org/spec/1.2/spec.html#schema/JSON/
 287. https://yaml.org/spec/1.2/spec.html#tag/repository/
 288. https://yaml.org/type/binary.html
 289. https://yaml.org/type/omap.html
 290. https://yaml.org/type/set.html
 291. https://yaml.org/spec/1.2/spec.html#tag//
 292. https://yaml.org/spec/1.2/spec.html#! tag indicator//
 293. https://yaml.org/spec/1.2/spec.html#tag/global/
 294. https://yaml.org/spec/1.2/spec.html#tag/shorthand/
 295. https://yaml.org/spec/1.2/spec.html#tag/handle/
 296. https://yaml.org/spec/1.2/spec.html#application//
 297. https://yaml.org/spec/1.2/spec.html#tag/local/
 298. https://yaml.org/spec/1.2/spec.html#present//
 299. https://yaml.org/spec/1.2/spec.html#native data structure//
 300. https://yaml.org/spec/1.2/spec.html#representation//
 301. https://yaml.org/spec/1.2/spec.html#present//
 302. https://yaml.org/spec/1.2/spec.html#representation//
 303. https://yaml.org/spec/1.2/spec.html#stream//
 304. https://yaml.org/spec/1.2/spec.html#representation//
 305. https://yaml.org/spec/1.2/spec.html#serialization//
 306. https://yaml.org/spec/1.2/spec.html#presentation//
 307. https://yaml.org/spec/1.2/spec.html#representation//
 308. https://yaml.org/spec/1.2/spec.html#native data structure//
 309. https://yaml.org/spec/1.2/spec.html#serialization//
 310. https://yaml.org/spec/1.2/spec.html#representation//
 311. https://yaml.org/spec/1.2/spec.html#presentation//
 312. https://yaml.org/spec/1.2/spec.html#serialization//
 313. https://yaml.org/spec/1.2/spec.html#native data structure//
 314. https://yaml.org/spec/1.2/spec.html#stream//
 315. https://yaml.org/spec/1.2/spec.html#serialization//
 316. https://yaml.org/spec/1.2/spec.html#representation//
 317. https://yaml.org/spec/1.2/spec.html#native data structure//
 318. https://yaml.org/spec/1.2/spec.html#stream//
 319. https://yaml.org/spec/1.2/spec.html#dump//
 320. https://yaml.org/spec/1.2/spec.html#load//
 321. https://yaml.org/spec/1.2/spec.html#native data structure//
 322. https://yaml.org/spec/1.2/spec.html#construct//
 323. https://yaml.org/spec/1.2/spec.html#representation//
 324. https://yaml.org/spec/1.2/spec.html#key/order/
 325. https://yaml.org/spec/1.2/spec.html#comment//
 326. https://yaml.org/spec/1.2/spec.html#tag/handle/
 327. https://yaml.org/spec/1.2/spec.html#compose//
 328. https://yaml.org/spec/1.2/spec.html#stream//
 329. https://yaml.org/spec/1.2/spec.html#kind//
 330. https://yaml.org/spec/1.2/spec.html#sequence//
 331. https://yaml.org/spec/1.2/spec.html#mapping//
 332. https://yaml.org/spec/1.2/spec.html#equality//
 333. https://yaml.org/spec/1.2/spec.html#key//
 334. https://yaml.org/spec/1.2/spec.html#value//
 335. https://yaml.org/spec/1.2/spec.html#scalar//
 336. https://yaml.org/spec/1.2/spec.html#sequence//
 337. https://yaml.org/spec/1.2/spec.html#mapping//
 338. https://yaml.org/spec/1.2/spec.html#scalar//
 339. https://yaml.org/spec/1.2/spec.html#node//
 340. https://yaml.org/spec/1.2/spec.html#kind//
 341. https://yaml.org/spec/1.2/spec.html#content//
 342. https://yaml.org/spec/1.2/spec.html#tag//
 343. https://yaml.org/spec/1.2/spec.html#tag/global/
 344. https://yaml.org/spec/1.2/spec.html#tag/local/
 345. https://yaml.org/spec/1.2/spec.html#application//
 346. https://yaml.org/spec/1.2/spec.html#scalar//
 347. https://yaml.org/spec/1.2/spec.html#tag/global/
 348. https://yaml.org/spec/1.2/spec.html#mapping//
 349. https://yaml.org/spec/1.2/spec.html#tag/local/
 350. https://yaml.org/spec/1.2/spec.html#representation//
 351. https://yaml.org/spec/1.2/spec.html#representation//
 352. https://yaml.org/spec/1.2/spec.html#key//
 353. https://yaml.org/spec/1.2/spec.html#node//
 354. https://yaml.org/spec/1.2/spec.html#key/order/
 355. https://yaml.org/spec/1.2/spec.html#key//
 356. https://yaml.org/spec/1.2/spec.html#node//
 357. https://yaml.org/spec/1.2/spec.html#alias//
 358. https://yaml.org/spec/1.2/spec.html#processor//
 359. https://yaml.org/spec/1.2/spec.html#key/order/
 360. https://yaml.org/spec/1.2/spec.html#anchor//
 361. https://yaml.org/spec/1.2/spec.html#application//
 362. https://yaml.org/spec/1.2/spec.html#serialization//
 363. https://yaml.org/spec/1.2/spec.html#serialization//
 364. https://yaml.org/spec/1.2/spec.html#stream//
 365. https://yaml.org/spec/1.2/spec.html#processor//
 366. https://yaml.org/spec/1.2/spec.html#stream//
 367. https://yaml.org/spec/1.2/spec.html#style//
 368. https://yaml.org/spec/1.2/spec.html#scalar/content format/
 369. https://yaml.org/spec/1.2/spec.html#space/indentation/
 370. https://yaml.org/spec/1.2/spec.html#tag/handle/
 371. https://yaml.org/spec/1.2/spec.html#tag//
 372. https://yaml.org/spec/1.2/spec.html#tag/non-specific/
 373. https://yaml.org/spec/1.2/spec.html#directive//
 374. https://yaml.org/spec/1.2/spec.html#comment//
 375. https://yaml.org/spec/1.2/spec.html#application//
 376. https://yaml.org/spec/1.2/spec.html#native data structure//
 377. https://yaml.org/spec/1.2/spec.html#stream//
 378. https://yaml.org/spec/1.2/spec.html#present//
 379. https://yaml.org/spec/1.2/spec.html#stream//
 380. https://yaml.org/spec/1.2/spec.html#presentation/detail/
 381. https://yaml.org/spec/1.2/spec.html#present//
 382. https://yaml.org/spec/1.2/spec.html#serialization//
 383. https://yaml.org/spec/1.2/spec.html#stream/ill-formed/
 384. https://yaml.org/spec/1.2/spec.html#serialization//
 385. https://yaml.org/spec/1.2/spec.html#representation//
 386. https://yaml.org/spec/1.2/spec.html#serialization/detail/
 387. https://yaml.org/spec/1.2/spec.html#serialize//
 388. https://yaml.org/spec/1.2/spec.html#representation//
 389. https://yaml.org/spec/1.2/spec.html#load/failure point/
 390. https://yaml.org/spec/1.2/spec.html#native data structure//
 391. https://yaml.org/spec/1.2/spec.html#representation//
 392. https://yaml.org/spec/1.2/spec.html#representation//
 393. https://yaml.org/spec/1.2/spec.html#serialization//
 394. https://yaml.org/spec/1.2/spec.html#presentation/detail/
 395. https://yaml.org/spec/1.2/spec.html#comment//
 396. https://yaml.org/spec/1.2/spec.html#directive//
 397. https://yaml.org/spec/1.2/spec.html#key/order/
 398. https://yaml.org/spec/1.2/spec.html#style//
 399. https://yaml.org/spec/1.2/spec.html#scalar/content format/
 400. https://yaml.org/spec/1.2/spec.html#space/indentation/
 401. https://yaml.org/spec/1.2/spec.html#tag/unavailable/
 402. https://yaml.org/spec/1.2/spec.html#native data structure//
 403. https://yaml.org/spec/1.2/spec.html#serialization//
 404. https://yaml.org/spec/1.2/spec.html#presentation//
 405. https://yaml.org/spec/1.2/spec.html#representation//
 406. https://yaml.org/spec/1.2/spec.html#key/order/
 407. https://yaml.org/spec/1.2/spec.html#key//
 408. https://yaml.org/spec/1.2/spec.html#representation//
 409. https://yaml.org/spec/1.2/spec.html#serialization/detail/
 410. https://yaml.org/spec/1.2/spec.html#application//
 411. https://yaml.org/spec/1.2/spec.html#space/indentation/
 412. https://yaml.org/spec/1.2/spec.html#style//
 413. https://yaml.org/spec/1.2/spec.html#presentation/detail/
 414. https://yaml.org/spec/1.2/spec.html#serialization//
 415. https://yaml.org/spec/1.2/spec.html#representation//
 416. https://yaml.org/spec/1.2/spec.html#serialization//
 417. https://yaml.org/spec/1.2/spec.html#presentation//
 418. https://yaml.org/spec/1.2/spec.html#representation//
 419. https://yaml.org/spec/1.2/spec.html#application//
 420. https://yaml.org/spec/1.2/spec.html#serialization//
 421. https://yaml.org/spec/1.2/spec.html#presentation//
 422. https://yaml.org/spec/1.2/spec.html#native data structure//
 423. https://yaml.org/spec/1.2/spec.html#tag//
 424. https://yaml.org/spec/1.2/spec.html#node//
 425. https://yaml.org/spec/1.2/spec.html#node//
 426. https://yaml.org/spec/1.2/spec.html#node//
 427. http://www.nist.gov/dads/HTML/directedGraph.html
 428. https://yaml.org/spec/1.2/spec.html#node//
 429. https://yaml.org/spec/1.2/spec.html#node//
 430. https://yaml.org/spec/1.2/spec.html#node//
 431. https://yaml.org/spec/1.2/spec.html#node//
 432. https://yaml.org/spec/1.2/spec.html#collection//
 433. https://yaml.org/spec/1.2/spec.html#node//
 434. https://yaml.org/spec/1.2/spec.html#node//
 435. https://yaml.org/spec/1.2/spec.html#scalar//
 436. https://yaml.org/spec/1.2/spec.html#kind//
 437. https://yaml.org/spec/1.2/spec.html#collection//
 438. https://yaml.org/spec/1.2/spec.html#sequence//
 439. https://yaml.org/spec/1.2/spec.html#mapping//
 440. https://yaml.org/spec/1.2/spec.html#mapping//
 441. https://yaml.org/spec/1.2/spec.html#key//
 442. https://yaml.org/spec/1.2/spec.html#equality//
 443. https://yaml.org/spec/1.2/spec.html#representation//
 444. https://yaml.org/spec/1.2/spec.html#native data structure//
 445. https://yaml.org/spec/1.2/spec.html#tag//
 446. https://yaml.org/spec/1.2/spec.html#present//
 447. https://yaml.org/spec/1.2/spec.html#equality//
 448. https://yaml.org/spec/1.2/spec.html#represent//
 449. https://yaml.org/spec/1.2/spec.html#native data structure//
 450. http://www.ietf.org/rfc/rfc2396.txt
 451. https://yaml.org/spec/1.2/spec.html#application//
 452. http://www.faqs.org/rfcs/rfc4151.html
 453. https://yaml.org/spec/1.2/spec.html#application//
 454. https://yaml.org/spec/1.2/spec.html#directive/TAG/
 455. https://yaml.org/spec/1.2/spec.html#% escaping in URI//
 456. https://yaml.org/spec/1.2/spec.html#node//
 457. https://yaml.org/spec/1.2/spec.html#kind//
 458. https://yaml.org/spec/1.2/spec.html#scalar//
 459. https://yaml.org/spec/1.2/spec.html#sequence//
 460. https://yaml.org/spec/1.2/spec.html#mapping//
 461. https://yaml.org/spec/1.2/spec.html#scalar//
 462. https://yaml.org/spec/1.2/spec.html#scalar/content format/
 463. https://yaml.org/spec/1.2/spec.html#scalar/canonical form/
 464. https://yaml.org/spec/1.2/spec.html#equality//
 465. https://yaml.org/spec/1.2/spec.html#content//
 466. https://yaml.org/spec/1.2/spec.html#tag/resolution/
 467. https://yaml.org/spec/1.2/spec.html#node//
 468. https://yaml.org/spec/1.2/spec.html#mapping//
 469. https://yaml.org/spec/1.2/spec.html#key//
 470. https://yaml.org/spec/1.2/spec.html#representation//
 471. https://yaml.org/spec/1.2/spec.html#node//
 472. https://yaml.org/spec/1.2/spec.html#scalar/content format/
 473. https://yaml.org/spec/1.2/spec.html#key//
 474. https://yaml.org/spec/1.2/spec.html#mapping//
 475. https://yaml.org/spec/1.2/spec.html#processor//
 476. https://yaml.org/spec/1.2/spec.html#scalar/content format/
 477. https://yaml.org/spec/1.2/spec.html#key//
 478. https://yaml.org/spec/1.2/spec.html#scalar//
 479. https://yaml.org/spec/1.2/spec.html#scalar//
 480. https://yaml.org/spec/1.2/spec.html#tag//
 481. https://yaml.org/spec/1.2/spec.html#scalar/content format/
 482. https://yaml.org/spec/1.2/spec.html#present//
 483. https://yaml.org/spec/1.2/spec.html#scalar/content format/
 484. https://yaml.org/spec/1.2/spec.html#node//
 485. https://yaml.org/spec/1.2/spec.html#tag//
 486. https://yaml.org/spec/1.2/spec.html#content//
 487. https://yaml.org/spec/1.2/spec.html#tag//
 488. https://yaml.org/spec/1.2/spec.html#kind//
 489. https://yaml.org/spec/1.2/spec.html#node//
 490. https://yaml.org/spec/1.2/spec.html#kind//
 491. https://yaml.org/spec/1.2/spec.html#scalar//
 492. https://yaml.org/spec/1.2/spec.html#tag//
 493. https://yaml.org/spec/1.2/spec.html#collection//
 494. https://yaml.org/spec/1.2/spec.html#sequence//
 495. https://yaml.org/spec/1.2/spec.html#tag//
 496. https://yaml.org/spec/1.2/spec.html#node//
 497. https://yaml.org/spec/1.2/spec.html#sequence//
 498. https://yaml.org/spec/1.2/spec.html#node//
 499. https://yaml.org/spec/1.2/spec.html#sequence//
 500. https://yaml.org/spec/1.2/spec.html#mapping//
 501. https://yaml.org/spec/1.2/spec.html#tag//
 502. https://yaml.org/spec/1.2/spec.html#key//
 503. https://yaml.org/spec/1.2/spec.html#key//
 504. https://yaml.org/spec/1.2/spec.html#value//
 505. https://yaml.org/spec/1.2/spec.html#mapping//
 506. https://yaml.org/spec/1.2/spec.html#processor//
 507. https://yaml.org/spec/1.2/spec.html#tag//
 508. https://yaml.org/spec/1.2/spec.html#tag//
 509. https://yaml.org/spec/1.2/spec.html#present//
 510. https://yaml.org/spec/1.2/spec.html#node//
 511. https://yaml.org/spec/1.2/spec.html#represent//
 512. https://yaml.org/spec/1.2/spec.html#native data structure//
 513. https://yaml.org/spec/1.2/spec.html#node//
 514. https://yaml.org/spec/1.2/spec.html#processor//
 515. https://yaml.org/spec/1.2/spec.html#scalar//
 516. https://yaml.org/spec/1.2/spec.html#collection//
 517. https://yaml.org/spec/1.2/spec.html#representation//
 518. https://yaml.org/spec/1.2/spec.html#key/order/
 519. https://yaml.org/spec/1.2/spec.html#key//
 520. https://yaml.org/spec/1.2/spec.html#alias//
 521. https://yaml.org/spec/1.2/spec.html#node//
 522. https://yaml.org/spec/1.2/spec.html#node//
 523. https://yaml.org/spec/1.2/spec.html#construct//
 524. https://yaml.org/spec/1.2/spec.html#native data structure//
 525. https://yaml.org/spec/1.2/spec.html#key/order/
 526. https://yaml.org/spec/1.2/spec.html#anchor//
 527. https://yaml.org/spec/1.2/spec.html#application//
 528. https://yaml.org/spec/1.2/spec.html#representation//
 529. https://yaml.org/spec/1.2/spec.html#key//
 530. https://yaml.org/spec/1.2/spec.html#serialize//
 531. https://yaml.org/spec/1.2/spec.html#mapping//
 532. https://yaml.org/spec/1.2/spec.html#key//
 533. https://yaml.org/spec/1.2/spec.html#serialization/detail/
 534. https://yaml.org/spec/1.2/spec.html#compose//
 535. https://yaml.org/spec/1.2/spec.html#representation//
 536. https://yaml.org/spec/1.2/spec.html#application//
 537. https://yaml.org/spec/1.2/spec.html#node//
 538. https://yaml.org/spec/1.2/spec.html#sequence//
 539. https://yaml.org/spec/1.2/spec.html#mapping//
 540. https://yaml.org/spec/1.2/spec.html#represent//
 541. https://yaml.org/spec/1.2/spec.html#sequence//
 542. https://yaml.org/spec/1.2/spec.html#mapping//
 543. https://yaml.org/spec/1.2/spec.html#mapping//
 544. https://yaml.org/spec/1.2/spec.html#key: value pair//
 545. https://yaml.org/spec/1.2/spec.html#style/single key:value pair mapping/
 546. https://yaml.org/spec/1.2/spec.html#representation//
 547. https://yaml.org/spec/1.2/spec.html#node//
 548. https://yaml.org/spec/1.2/spec.html#collection//
 549. https://yaml.org/spec/1.2/spec.html#serialize//
 550. https://yaml.org/spec/1.2/spec.html#node//
 551. https://yaml.org/spec/1.2/spec.html#serialize//
 552. https://yaml.org/spec/1.2/spec.html#alias//
 553. https://yaml.org/spec/1.2/spec.html#serialization/detail/
 554. https://yaml.org/spec/1.2/spec.html#compose//
 555. https://yaml.org/spec/1.2/spec.html#compose//
 556. https://yaml.org/spec/1.2/spec.html#representation//
 557. https://yaml.org/spec/1.2/spec.html#serialize//
 558. https://yaml.org/spec/1.2/spec.html#node//
 559. https://yaml.org/spec/1.2/spec.html#serialization//
 560. https://yaml.org/spec/1.2/spec.html#serialization//
 561. https://yaml.org/spec/1.2/spec.html#node//
 562. https://yaml.org/spec/1.2/spec.html#serialization//
 563. https://yaml.org/spec/1.2/spec.html#stream//
 564. https://yaml.org/spec/1.2/spec.html#style//
 565. https://yaml.org/spec/1.2/spec.html#scalar/content format/
 566. https://yaml.org/spec/1.2/spec.html#comment//
 567. https://yaml.org/spec/1.2/spec.html#directive//
 568. https://yaml.org/spec/1.2/spec.html#presentation/detail/
 569. https://yaml.org/spec/1.2/spec.html#present//
 570. https://yaml.org/spec/1.2/spec.html#serialization//
 571. https://yaml.org/spec/1.2/spec.html#processor//
 572. https://yaml.org/spec/1.2/spec.html#presentation/detail/
 573. https://yaml.org/spec/1.2/spec.html#parse//
 574. https://yaml.org/spec/1.2/spec.html#serialization//
 575. https://yaml.org/spec/1.2/spec.html#serialization//
 576. https://yaml.org/spec/1.2/spec.html#document//
 577. https://yaml.org/spec/1.2/spec.html#marker//
 578. https://yaml.org/spec/1.2/spec.html#node//
 579. https://yaml.org/spec/1.2/spec.html#serialization//
 580. https://yaml.org/spec/1.2/spec.html#representation//
 581. https://yaml.org/spec/1.2/spec.html#node//
 582. https://yaml.org/spec/1.2/spec.html#kind//
 583. https://yaml.org/spec/1.2/spec.html#presentation/detail/
 584. https://yaml.org/spec/1.2/spec.html#serialization//
 585. https://yaml.org/spec/1.2/spec.html#representation//
 586. https://yaml.org/spec/1.2/spec.html#style/block/
 587. https://yaml.org/spec/1.2/spec.html#space/indentation/
 588. https://yaml.org/spec/1.2/spec.html#style/flow/
 589. https://yaml.org/spec/1.2/spec.html#indicator//
 590. https://yaml.org/spec/1.2/spec.html#style/block/scalar
 591. https://yaml.org/spec/1.2/spec.html#style/block/literal
 592. https://yaml.org/spec/1.2/spec.html#style/block/folded
 593. https://yaml.org/spec/1.2/spec.html#style/flow/scalar
 594. https://yaml.org/spec/1.2/spec.html#style/flow/plain
 595. https://yaml.org/spec/1.2/spec.html#style/flow/single-quoted
 596. https://yaml.org/spec/1.2/spec.html#style/flow/double-quoted
 597. https://yaml.org/spec/1.2/spec.html#style/block/sequence
 598. https://yaml.org/spec/1.2/spec.html#style/block/mapping
 599. https://yaml.org/spec/1.2/spec.html#style/block/
 600. https://yaml.org/spec/1.2/spec.html#collection//
 601. https://yaml.org/spec/1.2/spec.html#style/compact block collection/
 602. https://yaml.org/spec/1.2/spec.html#style/single key:value pair mapping/
 603. https://yaml.org/spec/1.2/spec.html#style/flow/mapping
 604. https://yaml.org/spec/1.2/spec.html#key: value pair//
 605. https://yaml.org/spec/1.2/spec.html#style/flow/sequence
 606. https://yaml.org/spec/1.2/spec.html#scalar//
 607. https://yaml.org/spec/1.2/spec.html#present//
 608. https://yaml.org/spec/1.2/spec.html#tag//
 609. https://yaml.org/spec/1.2/spec.html#scalar/canonical form/
 610. https://yaml.org/spec/1.2/spec.html#equality//
 611. https://yaml.org/spec/1.2/spec.html#style//
 612. https://yaml.org/spec/1.2/spec.html#presentation/detail/
 613. https://yaml.org/spec/1.2/spec.html#serialization//
 614. https://yaml.org/spec/1.2/spec.html#representation//
 615. https://yaml.org/spec/1.2/spec.html#comment//
 616. https://yaml.org/spec/1.2/spec.html#presentation/detail/
 617. https://yaml.org/spec/1.2/spec.html#serialization//
 618. https://yaml.org/spec/1.2/spec.html#representation//
 619. https://yaml.org/spec/1.2/spec.html#node//
 620. https://yaml.org/spec/1.2/spec.html#scalar//
 621. https://yaml.org/spec/1.2/spec.html#scalar//
 622. https://yaml.org/spec/1.2/spec.html#collection//
 623. https://yaml.org/spec/1.2/spec.html#document//
 624. https://yaml.org/spec/1.2/spec.html#directive//
 625. https://yaml.org/spec/1.2/spec.html#processor//
 626. https://yaml.org/spec/1.2/spec.html#presentation/detail/
 627. https://yaml.org/spec/1.2/spec.html#serialization//
 628. https://yaml.org/spec/1.2/spec.html#representation//
 629. https://yaml.org/spec/1.2/spec.html#directive/YAML/
 630. https://yaml.org/spec/1.2/spec.html#directive/TAG/
 631. https://yaml.org/spec/1.2/spec.html#directive/reserved/
 632. https://yaml.org/spec/1.2/spec.html#load//
 633. https://yaml.org/spec/1.2/spec.html#native data structure//
 634. https://yaml.org/spec/1.2/spec.html#stream//
 635. https://yaml.org/spec/1.2/spec.html#stream//
 636. https://yaml.org/spec/1.2/spec.html#stream/ill-formed/
 637. https://yaml.org/spec/1.2/spec.html#alias//
 638. https://yaml.org/spec/1.2/spec.html#alias/unidentified/
 639. https://yaml.org/spec/1.2/spec.html#tag/non-specific/
 640. https://yaml.org/spec/1.2/spec.html#tag/unresolved/
 641. https://yaml.org/spec/1.2/spec.html#tag//
 642. https://yaml.org/spec/1.2/spec.html#tag/unrecognized/
 643. https://yaml.org/spec/1.2/spec.html#content//
 644. https://yaml.org/spec/1.2/spec.html#invalid content//
 645. https://yaml.org/spec/1.2/spec.html#tag/unavailable/
 646. https://yaml.org/spec/1.2/spec.html#tag/resolution/
 647. https://yaml.org/spec/1.2/spec.html#tag//
 648. https://yaml.org/spec/1.2/spec.html#node//
 649. https://yaml.org/spec/1.2/spec.html#scalar/canonical form/
 650. https://yaml.org/spec/1.2/spec.html#scalar/content format/
 651. https://yaml.org/spec/1.2/spec.html#document//
 652. https://yaml.org/spec/1.2/spec.html#tag//
 653. https://yaml.org/spec/1.2/spec.html#node//
 654. https://yaml.org/spec/1.2/spec.html#scalar/canonical form/
 655. https://yaml.org/spec/1.2/spec.html#scalar/content format/
 656. https://yaml.org/spec/1.2/spec.html#equality//
 657. https://yaml.org/spec/1.2/spec.html#construct//
 658. https://yaml.org/spec/1.2/spec.html#native data structure//
 659. https://yaml.org/spec/1.2/spec.html#stream/well-formed/
 660. https://yaml.org/spec/1.2/spec.html#stream//
 661. https://yaml.org/spec/1.2/spec.html#alias//
 662. https://yaml.org/spec/1.2/spec.html#node//
 663. https://yaml.org/spec/1.2/spec.html#alias/identified/
 664. https://yaml.org/spec/1.2/spec.html#anchor//
 665. https://yaml.org/spec/1.2/spec.html#processor//
 666. https://yaml.org/spec/1.2/spec.html#processor//
 667. https://yaml.org/spec/1.2/spec.html#tag//
 668. https://yaml.org/spec/1.2/spec.html#stream//
 669. https://yaml.org/spec/1.2/spec.html#parse//
 670. https://yaml.org/spec/1.2/spec.html#node//
 671. https://yaml.org/spec/1.2/spec.html#tag//
 672. https://yaml.org/spec/1.2/spec.html#style/flow/plain
 673. https://yaml.org/spec/1.2/spec.html#node//
 674. https://yaml.org/spec/1.2/spec.html#compose//
 675. https://yaml.org/spec/1.2/spec.html#representation/complete/
 676. https://yaml.org/spec/1.2/spec.html#tag/global/
 677. https://yaml.org/spec/1.2/spec.html#tag/local/
 678. https://yaml.org/spec/1.2/spec.html#tag//
 679. https://yaml.org/spec/1.2/spec.html#node//
 680. https://yaml.org/spec/1.2/spec.html#node//
 681. https://yaml.org/spec/1.2/spec.html#node/root/
 682. https://yaml.org/spec/1.2/spec.html#node//
 683. https://yaml.org/spec/1.2/spec.html#content//
 684. https://yaml.org/spec/1.2/spec.html#kind//
 685. https://yaml.org/spec/1.2/spec.html#node//
 686. https://yaml.org/spec/1.2/spec.html#node//
 687. https://yaml.org/spec/1.2/spec.html#alias//
 688. https://yaml.org/spec/1.2/spec.html#anchor//
 689. https://yaml.org/spec/1.2/spec.html#node//
 690. https://yaml.org/spec/1.2/spec.html#presentation/detail/
 691. https://yaml.org/spec/1.2/spec.html#comment//
 692. https://yaml.org/spec/1.2/spec.html#space/indentation/
 693. https://yaml.org/spec/1.2/spec.html#style//
 694. https://yaml.org/spec/1.2/spec.html#content//
 695. https://yaml.org/spec/1.2/spec.html#node//
 696. https://yaml.org/spec/1.2/spec.html#content//
 697. https://yaml.org/spec/1.2/spec.html#key//
 698. https://yaml.org/spec/1.2/spec.html#node/root/
 699. https://yaml.org/spec/1.2/spec.html#node//
 700. https://yaml.org/spec/1.2/spec.html#content//
 701. https://yaml.org/spec/1.2/spec.html#node//
 702. https://yaml.org/spec/1.2/spec.html#collection//
 703. https://yaml.org/spec/1.2/spec.html#content//
 704. https://yaml.org/spec/1.2/spec.html#value//
 705. https://yaml.org/spec/1.2/spec.html#key//
 706. https://yaml.org/spec/1.2/spec.html#node//
 707. https://yaml.org/spec/1.2/spec.html#stream//
 708. https://yaml.org/spec/1.2/spec.html#content//
 709. https://yaml.org/spec/1.2/spec.html#parse//
 710. https://yaml.org/spec/1.2/spec.html#node//
 711. https://yaml.org/spec/1.2/spec.html#processor//
 712. https://yaml.org/spec/1.2/spec.html#processor//
 713. https://yaml.org/spec/1.2/spec.html#node//
 714. https://yaml.org/spec/1.2/spec.html#kind//
 715. https://yaml.org/spec/1.2/spec.html#stream//
 716. https://yaml.org/spec/1.2/spec.html#tag/property/
 717. https://yaml.org/spec/1.2/spec.html#node//
 718. https://yaml.org/spec/1.2/spec.html#sequence//
 719. https://yaml.org/spec/1.2/spec.html#mapping//
 720. https://yaml.org/spec/1.2/spec.html#kind//
 721. https://yaml.org/spec/1.2/spec.html#application//
 722. https://yaml.org/spec/1.2/spec.html#style/flow/plain
 723. https://yaml.org/spec/1.2/spec.html#application//
 724. https://yaml.org/spec/1.2/spec.html#content//
 725. https://yaml.org/spec/1.2/spec.html#mapping//
 726. https://yaml.org/spec/1.2/spec.html#key//
 727. https://yaml.org/spec/1.2/spec.html#sequence//
 728. https://yaml.org/spec/1.2/spec.html#application//
 729. https://yaml.org/spec/1.2/spec.html#processor//
 730. https://yaml.org/spec/1.2/spec.html#application//
 731. https://yaml.org/spec/1.2/spec.html#document//
 732. https://yaml.org/spec/1.2/spec.html#processor//
 733. https://yaml.org/spec/1.2/spec.html#compose//
 734. https://yaml.org/spec/1.2/spec.html#representation/complete/
 735. https://yaml.org/spec/1.2/spec.html#processor//
 736. https://yaml.org/spec/1.2/spec.html#compose//
 737. https://yaml.org/spec/1.2/spec.html#representation/partial/
 738. https://yaml.org/spec/1.2/spec.html#kind//
 739. https://yaml.org/spec/1.2/spec.html#node//
 740. https://yaml.org/spec/1.2/spec.html#tag//
 741. https://yaml.org/spec/1.2/spec.html#processor//
 742. https://yaml.org/spec/1.2/spec.html#content//
 743. https://yaml.org/spec/1.2/spec.html#tag//
 744. https://yaml.org/spec/1.2/spec.html#document//
 745. https://yaml.org/spec/1.2/spec.html#scalar//
 746. https://yaml.org/spec/1.2/spec.html#representation/partial/
 747. https://yaml.org/spec/1.2/spec.html#compose//
 748. https://yaml.org/spec/1.2/spec.html#processor//
 749. https://yaml.org/spec/1.2/spec.html#compose//
 750. https://yaml.org/spec/1.2/spec.html#representation/complete/
 751. https://yaml.org/spec/1.2/spec.html#collection//
 752. https://yaml.org/spec/1.2/spec.html#collection//
 753. https://yaml.org/spec/1.2/spec.html#equality//
 754. https://yaml.org/spec/1.2/spec.html#collection//
 755. https://yaml.org/spec/1.2/spec.html#representation/complete/
 756. https://yaml.org/spec/1.2/spec.html#construct//
 757. https://yaml.org/spec/1.2/spec.html#native data structure//
 758. https://yaml.org/spec/1.2/spec.html#tag//
 759. https://yaml.org/spec/1.2/spec.html#tag//
 760. https://yaml.org/spec/1.2/spec.html#processor//
 761. https://yaml.org/spec/1.2/spec.html#construct//
 762. https://yaml.org/spec/1.2/spec.html#native data structure//
 763. https://yaml.org/spec/1.2/spec.html#representation/complete/
 764. https://yaml.org/spec/1.2/spec.html#compose//
 765. https://yaml.org/spec/1.2/spec.html#application//
 766. https://yaml.org/spec/1.2/spec.html#representation//
 767. https://yaml.org/spec/1.2/spec.html#stream//
 768. https://yaml.org/spec/1.2/spec.html#b-break
 769. https://yaml.org/spec/1.2/spec.html#style/flow/collection
 770. https://yaml.org/spec/1.2/spec.html#style/flow/double-quoted
 771. https://yaml.org/spec/1.2/spec.html#tag//
 772. https://yaml.org/spec/1.2/spec.html#node//
 773. http://hackage.haskell.org/cgi-bin/hackage-scripts/package/YamlReference
 774. http://dev.yaml.org/ypaste
 775. https://yaml.org/spec/1.2/spec.html#parse//
 776. https://yaml.org/spec/1.2/spec.html#presentation//
 777. https://yaml.org/spec/1.2/spec.html#space/indentation/
 778. https://yaml.org/spec/1.2/spec.html#style/block/
 779. https://yaml.org/spec/1.2/spec.html#style/flow/
 780. https://yaml.org/spec/1.2/spec.html#style/block/
 781. https://yaml.org/spec/1.2/spec.html#space/indentation/
 782. https://yaml.org/spec/1.2/spec.html#space/indentation/
 783. https://yaml.org/spec/1.2/spec.html#- block sequence entry//
 784. https://yaml.org/spec/1.2/spec.html#style/block/sequence
 785. https://yaml.org/spec/1.2/spec.html#style/block/sequence
 786. https://yaml.org/spec/1.2/spec.html#style/flow/
 787. https://yaml.org/spec/1.2/spec.html#indicator//
 788. https://yaml.org/spec/1.2/spec.html#tag//
 789. https://yaml.org/spec/1.2/spec.html#style/flow/single-quoted
 790. https://yaml.org/spec/1.2/spec.html#style/flow/plain
 791. https://yaml.org/spec/1.2/spec.html#indicator//
 792. https://yaml.org/spec/1.2/spec.html#style/block/mapping
 793. https://yaml.org/spec/1.2/spec.html#style/flow/mapping
 794. https://yaml.org/spec/1.2/spec.html#style/flow/collection
 795. https://yaml.org/spec/1.2/spec.html#chomping//
 796. https://yaml.org/spec/1.2/spec.html#line break//
 797. https://yaml.org/spec/1.2/spec.html#chomping/strip/
 798. https://yaml.org/spec/1.2/spec.html#chomping/clip/
 799. https://yaml.org/spec/1.2/spec.html#chomping/keep/
 800. https://yaml.org/spec/1.2/spec.html#line break//
 801. https://yaml.org/spec/1.2/spec.html#line break//
 802. https://yaml.org/spec/1.2/spec.html#line break//
 803. https://yaml.org/spec/1.2/spec.html#space/white/
 804. https://yaml.org/spec/1.2/spec.html#space/white/
 805. https://yaml.org/spec/1.2/spec.html#space/indentation/
 806. https://yaml.org/spec/1.2/spec.html#stream//
 807. https://yaml.org/spec/1.2/spec.html#processor//
 808. https://yaml.org/spec/1.2/spec.html#processor//
 809. https://yaml.org/spec/1.2/spec.html#present//
 810. https://yaml.org/spec/1.2/spec.html#escaping/in double-quoted scalars/
 811. https://yaml.org/spec/1.2/spec.html#escaping/in double-quoted scalars/
 812. https://yaml.org/spec/1.2/spec.html#JSON compatibility//
 813. https://yaml.org/spec/1.2/spec.html#processor//
 814. https://yaml.org/spec/1.2/spec.html#style/flow/double-quoted
 815. https://yaml.org/spec/1.2/spec.html#escaping/in double-quoted scalars/
 816. https://yaml.org/spec/1.2/spec.html#style/flow/double-quoted
 817. https://yaml.org/spec/1.2/spec.html#style/flow/double-quoted
 818. https://yaml.org/spec/1.2/spec.html#tab//
 819. https://yaml.org/spec/1.2/spec.html#style/flow/double-quoted
 820. https://yaml.org/spec/1.2/spec.html#presentation/detail/
 821. https://yaml.org/spec/1.2/spec.html#content//
 822. https://yaml.org/spec/1.2/spec.html#processor//
 823. https://yaml.org/spec/1.2/spec.html#JSON compatibility//
 824. https://yaml.org/spec/1.2/spec.html#stream//
 825. https://yaml.org/spec/1.2/spec.html#stream//
 826. https://yaml.org/spec/1.2/spec.html#stream//
 827. https://yaml.org/spec/1.2/spec.html#document//
 828. https://yaml.org/spec/1.2/spec.html#document//
 829. https://yaml.org/spec/1.2/spec.html#stream//
 830. https://yaml.org/spec/1.2/spec.html#JSON compatibility//
 831. https://yaml.org/spec/1.2/spec.html#style/flow/double-quoted
 832. https://yaml.org/spec/1.2/spec.html#content//
 833. https://yaml.org/spec/1.2/spec.html#escaping/in double-quoted scalars/
 834. https://yaml.org/spec/1.2/spec.html#stream//
 835. https://yaml.org/spec/1.2/spec.html#stream//
 836. http://www.unicode.org/unicode/faq/utf_bom.html
 837. https://yaml.org/spec/1.2/spec.html#c-byte-order-mark
 838. https://yaml.org/spec/1.2/spec.html#- block sequence entry//
 839. https://yaml.org/spec/1.2/spec.html#style/block/sequence
 840. https://yaml.org/spec/1.2/spec.html#? mapping key//
 841. https://yaml.org/spec/1.2/spec.html#key//
 842. https://yaml.org/spec/1.2/spec.html#: mapping value//
 843. https://yaml.org/spec/1.2/spec.html#value//
 844. https://yaml.org/spec/1.2/spec.html#c-sequence-entry
 845. https://yaml.org/spec/1.2/spec.html#c-mapping-key
 846. https://yaml.org/spec/1.2/spec.html#c-mapping-value
 847. https://yaml.org/spec/1.2/spec.html#, end flow entry//
 848. https://yaml.org/spec/1.2/spec.html#style/flow/collection
 849. https://yaml.org/spec/1.2/spec.html#[ start flow sequence//
 850. https://yaml.org/spec/1.2/spec.html#style/flow/sequence
 851. https://yaml.org/spec/1.2/spec.html#] end flow sequence//
 852. https://yaml.org/spec/1.2/spec.html#style/flow/sequence
 853. https://yaml.org/spec/1.2/spec.html#{ start flow mapping//
 854. https://yaml.org/spec/1.2/spec.html#style/flow/mapping
 855. https://yaml.org/spec/1.2/spec.html#} end flow mapping//
 856. https://yaml.org/spec/1.2/spec.html#style/flow/mapping
 857. https://yaml.org/spec/1.2/spec.html#c-sequence-start
 858. https://yaml.org/spec/1.2/spec.html#c-sequence-end
 859. https://yaml.org/spec/1.2/spec.html#c-mapping-start
 860. https://yaml.org/spec/1.2/spec.html#c-mapping-end
 861. https://yaml.org/spec/1.2/spec.html#c-collect-entry
 862. https://yaml.org/spec/1.2/spec.html## comment//
 863. https://yaml.org/spec/1.2/spec.html#comment//
 864. https://yaml.org/spec/1.2/spec.html#c-comment
 865. https://yaml.org/spec/1.2/spec.html#& anchor//
 866. https://yaml.org/spec/1.2/spec.html#anchor//
 867. https://yaml.org/spec/1.2/spec.html#* alias//
 868. https://yaml.org/spec/1.2/spec.html#alias//
 869. https://yaml.org/spec/1.2/spec.html#! tag indicator//
 870. https://yaml.org/spec/1.2/spec.html#tag//
 871. https://yaml.org/spec/1.2/spec.html#tag/handle/
 872. https://yaml.org/spec/1.2/spec.html#directive/TAG/
 873. https://yaml.org/spec/1.2/spec.html#tag/property/
 874. https://yaml.org/spec/1.2/spec.html#tag/local/
 875. https://yaml.org/spec/1.2/spec.html#tag/non-specific/
 876. https://yaml.org/spec/1.2/spec.html#style/flow/plain
 877. https://yaml.org/spec/1.2/spec.html#c-tag
 878. https://yaml.org/spec/1.2/spec.html#c-anchor
 879. https://yaml.org/spec/1.2/spec.html#c-alias
 880. https://yaml.org/spec/1.2/spec.html#| literal style//
 881. https://yaml.org/spec/1.2/spec.html#style/block/literal
 882. https://yaml.org/spec/1.2/spec.html#> folded style//
 883. https://yaml.org/spec/1.2/spec.html#style/block/folded
 884. https://yaml.org/spec/1.2/spec.html#c-literal
 885. https://yaml.org/spec/1.2/spec.html#c-folded
 886. https://yaml.org/spec/1.2/spec.html#' single-quoted style//
 887. https://yaml.org/spec/1.2/spec.html#style/flow/single-quoted
 888. https://yaml.org/spec/1.2/spec.html#" double-quoted style//
 889. https://yaml.org/spec/1.2/spec.html#style/flow/double-quoted
 890. https://yaml.org/spec/1.2/spec.html#c-single-quote
 891. https://yaml.org/spec/1.2/spec.html#c-double-quote
 892. https://yaml.org/spec/1.2/spec.html#% directive//
 893. https://yaml.org/spec/1.2/spec.html#directive//
 894. https://yaml.org/spec/1.2/spec.html#c-directive
 895. https://yaml.org/spec/1.2/spec.html#c-sequence-entry
 896. https://yaml.org/spec/1.2/spec.html#c-mapping-key
 897. https://yaml.org/spec/1.2/spec.html#c-mapping-value
 898. https://yaml.org/spec/1.2/spec.html#c-collect-entry
 899. https://yaml.org/spec/1.2/spec.html#c-sequence-start
 900. https://yaml.org/spec/1.2/spec.html#c-sequence-end
 901. https://yaml.org/spec/1.2/spec.html#c-mapping-start
 902. https://yaml.org/spec/1.2/spec.html#c-mapping-end
 903. https://yaml.org/spec/1.2/spec.html#c-comment
 904. https://yaml.org/spec/1.2/spec.html#c-anchor
 905. https://yaml.org/spec/1.2/spec.html#c-alias
 906. https://yaml.org/spec/1.2/spec.html#c-tag
 907. https://yaml.org/spec/1.2/spec.html#c-literal
 908. https://yaml.org/spec/1.2/spec.html#c-folded
 909. https://yaml.org/spec/1.2/spec.html#c-single-quote
 910. https://yaml.org/spec/1.2/spec.html#c-double-quote
 911. https://yaml.org/spec/1.2/spec.html#c-directive
 912. https://yaml.org/spec/1.2/spec.html#c-reserved
 913. https://yaml.org/spec/1.2/spec.html#[ start flow sequence//
 914. https://yaml.org/spec/1.2/spec.html#] end flow sequence//
 915. https://yaml.org/spec/1.2/spec.html#{ start flow mapping//
 916. https://yaml.org/spec/1.2/spec.html#} end flow mapping//
 917. https://yaml.org/spec/1.2/spec.html#, end flow entry//
 918. https://yaml.org/spec/1.2/spec.html#style/flow/collection
 919. https://yaml.org/spec/1.2/spec.html#c-collect-entry
 920. https://yaml.org/spec/1.2/spec.html#c-sequence-start
 921. https://yaml.org/spec/1.2/spec.html#c-sequence-end
 922. https://yaml.org/spec/1.2/spec.html#c-mapping-start
 923. https://yaml.org/spec/1.2/spec.html#c-mapping-end
 924. https://yaml.org/spec/1.2/spec.html#b-line-feed
 925. https://yaml.org/spec/1.2/spec.html#b-carriage-return
 926. https://yaml.org/spec/1.2/spec.html#YAML 1.1 processing//
 927. https://yaml.org/spec/1.2/spec.html#JSON compatibility//
 928. https://yaml.org/spec/1.2/spec.html#YAML 1.1 processing//
 929. https://yaml.org/spec/1.2/spec.html#processor//
 930. https://yaml.org/spec/1.2/spec.html#parse//
 931. https://yaml.org/spec/1.2/spec.html#YAML 1.1 processing//
 932. https://yaml.org/spec/1.2/spec.html#document//
 933. https://yaml.org/spec/1.2/spec.html#c-printable
 934. https://yaml.org/spec/1.2/spec.html#b-char
 935. https://yaml.org/spec/1.2/spec.html#c-byte-order-mark
 936. https://yaml.org/spec/1.2/spec.html#b-carriage-return
 937. https://yaml.org/spec/1.2/spec.html#b-line-feed
 938. https://yaml.org/spec/1.2/spec.html#b-carriage-return
 939. https://yaml.org/spec/1.2/spec.html#b-line-feed
 940. https://yaml.org/spec/1.2/spec.html#scalar//
 941. https://yaml.org/spec/1.2/spec.html#processor//
 942. https://yaml.org/spec/1.2/spec.html#parse//
 943. https://yaml.org/spec/1.2/spec.html#presentation/detail/
 944. https://yaml.org/spec/1.2/spec.html#content//
 945. https://yaml.org/spec/1.2/spec.html#b-break
 946. https://yaml.org/spec/1.2/spec.html#scalar//
 947. https://yaml.org/spec/1.2/spec.html#b-break
 948. https://yaml.org/spec/1.2/spec.html#processor//
 949. https://yaml.org/spec/1.2/spec.html#b-break
 950. https://yaml.org/spec/1.2/spec.html#s-space
 951. https://yaml.org/spec/1.2/spec.html#s-tab
 952. https://yaml.org/spec/1.2/spec.html#printable character//
 953. https://yaml.org/spec/1.2/spec.html#line break//
 954. https://yaml.org/spec/1.2/spec.html#nb-char
 955. https://yaml.org/spec/1.2/spec.html#s-white
 956. https://yaml.org/spec/1.2/spec.html#s-space
 957. https://yaml.org/spec/1.2/spec.html#s-tab
 958. https://yaml.org/spec/1.2/spec.html#escaping/in double-quoted scalars/
 959. https://yaml.org/spec/1.2/spec.html#ns-dec-digit
 960. https://yaml.org/spec/1.2/spec.html#ns-dec-digit
 961. https://yaml.org/spec/1.2/spec.html#ns-ascii-letter
 962. https://yaml.org/spec/1.2/spec.html#tag//
 963. http://www.ietf.org/rfc/rfc2396.txt
 964. http://www.ietf.org/rfc/rfc2732.txt
 965. https://yaml.org/spec/1.2/spec.html#processor//
 966. https://yaml.org/spec/1.2/spec.html#tag//
 967. https://yaml.org/spec/1.2/spec.html#present//
 968. https://yaml.org/spec/1.2/spec.html#stream//
 969. https://yaml.org/spec/1.2/spec.html#ns-hex-digit
 970. https://yaml.org/spec/1.2/spec.html#ns-hex-digit
 971. https://yaml.org/spec/1.2/spec.html#ns-word-char
 972. https://yaml.org/spec/1.2/spec.html#c-tag
 973. https://yaml.org/spec/1.2/spec.html#tag/handle/named
 974. https://yaml.org/spec/1.2/spec.html#tag/shorthand/
 975. https://yaml.org/spec/1.2/spec.html#tag/shorthand/
 976. https://yaml.org/spec/1.2/spec.html#[ start flow sequence//
 977. https://yaml.org/spec/1.2/spec.html#] end flow sequence//
 978. https://yaml.org/spec/1.2/spec.html#{ start flow mapping//
 979. https://yaml.org/spec/1.2/spec.html#} end flow mapping//
 980. https://yaml.org/spec/1.2/spec.html#, end flow entry//
 981. https://yaml.org/spec/1.2/spec.html#style/flow/collection
 982. https://yaml.org/spec/1.2/spec.html#ns-uri-char
 983. https://yaml.org/spec/1.2/spec.html#c-tag
 984. https://yaml.org/spec/1.2/spec.html#c-flow-indicator
 985. https://yaml.org/spec/1.2/spec.html#printable character//
 986. https://yaml.org/spec/1.2/spec.html#parse//
 987. https://yaml.org/spec/1.2/spec.html#presentation/detail/
 988. https://yaml.org/spec/1.2/spec.html#content//
 989. https://yaml.org/spec/1.2/spec.html#style/flow/double-quoted
 990. https://yaml.org/spec/1.2/spec.html#style/scalar/
 991. https://yaml.org/spec/1.2/spec.html#printable character//
 992. https://yaml.org/spec/1.2/spec.html#content//
 993. https://yaml.org/spec/1.2/spec.html#content//
 994. https://yaml.org/spec/1.2/spec.html#c-double-quote
 995. https://yaml.org/spec/1.2/spec.html#JSON compatibility//
 996. https://yaml.org/spec/1.2/spec.html#c-escape
 997. https://yaml.org/spec/1.2/spec.html#ns-hex-digit
 998. https://yaml.org/spec/1.2/spec.html#ns-hex-digit
 999. https://yaml.org/spec/1.2/spec.html#ns-hex-digit
1000. https://yaml.org/spec/1.2/spec.html#c-escape
1001. https://yaml.org/spec/1.2/spec.html#ns-esc-null
1002. https://yaml.org/spec/1.2/spec.html#ns-esc-bell
1003. https://yaml.org/spec/1.2/spec.html#ns-esc-backspace
1004. https://yaml.org/spec/1.2/spec.html#ns-esc-horizontal-tab
1005. https://yaml.org/spec/1.2/spec.html#ns-esc-line-feed
1006. https://yaml.org/spec/1.2/spec.html#ns-esc-vertical-tab
1007. https://yaml.org/spec/1.2/spec.html#ns-esc-form-feed
1008. https://yaml.org/spec/1.2/spec.html#ns-esc-carriage-return
1009. https://yaml.org/spec/1.2/spec.html#ns-esc-escape
1010. https://yaml.org/spec/1.2/spec.html#ns-esc-space
1011. https://yaml.org/spec/1.2/spec.html#ns-esc-double-quote
1012. https://yaml.org/spec/1.2/spec.html#ns-esc-slash
1013. https://yaml.org/spec/1.2/spec.html#ns-esc-backslash
1014. https://yaml.org/spec/1.2/spec.html#ns-esc-next-line
1015. https://yaml.org/spec/1.2/spec.html#ns-esc-non-breaking-space
1016. https://yaml.org/spec/1.2/spec.html#ns-esc-line-separator
1017. https://yaml.org/spec/1.2/spec.html#ns-esc-paragraph-separator
1018. https://yaml.org/spec/1.2/spec.html#ns-esc-8-bit
1019. https://yaml.org/spec/1.2/spec.html#ns-esc-16-bit
1020. https://yaml.org/spec/1.2/spec.html#ns-esc-32-bit
1021. https://yaml.org/spec/1.2/spec.html#c-ns-esc-char
1022. https://yaml.org/spec/1.2/spec.html#style/block/
1023. https://yaml.org/spec/1.2/spec.html#space//
1024. https://yaml.org/spec/1.2/spec.html#tab//
1025. https://yaml.org/spec/1.2/spec.html#tab//
1026. https://yaml.org/spec/1.2/spec.html#tab//
1027. https://yaml.org/spec/1.2/spec.html#space//
1028. https://yaml.org/spec/1.2/spec.html#presentation/detail/
1029. https://yaml.org/spec/1.2/spec.html#content//
1030. https://yaml.org/spec/1.2/spec.html#s-space
1031. https://yaml.org/spec/1.2/spec.html#style/block/
1032. https://yaml.org/spec/1.2/spec.html#s-space
1033. https://yaml.org/spec/1.2/spec.html#s-space
1034. https://yaml.org/spec/1.2/spec.html#node//
1035. https://yaml.org/spec/1.2/spec.html#node//
1036. https://yaml.org/spec/1.2/spec.html#node//
1037. https://yaml.org/spec/1.2/spec.html#content//
1038. https://yaml.org/spec/1.2/spec.html#node//
1039. https://yaml.org/spec/1.2/spec.html#s-indent(n)
1040. https://yaml.org/spec/1.2/spec.html#- block sequence entry//
1041. https://yaml.org/spec/1.2/spec.html#? mapping key//
1042. https://yaml.org/spec/1.2/spec.html#: mapping value//
1043. https://yaml.org/spec/1.2/spec.html#style/block/collection
1044. https://yaml.org/spec/1.2/spec.html#s-indent(n)
1045. https://yaml.org/spec/1.2/spec.html#space/indentation/
1046. https://yaml.org/spec/1.2/spec.html#scalar//
1047. https://yaml.org/spec/1.2/spec.html#space/white/
1048. https://yaml.org/spec/1.2/spec.html#space/white/
1049. https://yaml.org/spec/1.2/spec.html#tab//
1050. https://yaml.org/spec/1.2/spec.html#presentation/detail/
1051. https://yaml.org/spec/1.2/spec.html#content//
1052. https://yaml.org/spec/1.2/spec.html#s-white
1053. https://yaml.org/spec/1.2/spec.html#s-separate-in-line
1054. https://yaml.org/spec/1.2/spec.html#scalar//
1055. https://yaml.org/spec/1.2/spec.html#content//
1056. https://yaml.org/spec/1.2/spec.html#space/indentation/
1057. https://yaml.org/spec/1.2/spec.html#style/flow/scalar
1058. https://yaml.org/spec/1.2/spec.html#space/white/
1059. https://yaml.org/spec/1.2/spec.html#tab//
1060. https://yaml.org/spec/1.2/spec.html#presentation/detail/
1061. https://yaml.org/spec/1.2/spec.html#content//
1062. https://yaml.org/spec/1.2/spec.html#s-block-line-prefix(n)
1063. https://yaml.org/spec/1.2/spec.html#s-block-line-prefix(n)
1064. https://yaml.org/spec/1.2/spec.html#s-flow-line-prefix(n)
1065. https://yaml.org/spec/1.2/spec.html#s-flow-line-prefix(n)
1066. https://yaml.org/spec/1.2/spec.html#s-indent(n)
1067. https://yaml.org/spec/1.2/spec.html#s-indent(n)
1068. https://yaml.org/spec/1.2/spec.html#s-separate-in-line
1069. https://yaml.org/spec/1.2/spec.html#s-flow-line-prefix(n)
1070. https://yaml.org/spec/1.2/spec.html#s-block-line-prefix(n)
1071. https://yaml.org/spec/1.2/spec.html#s-indent(n)
1072. https://yaml.org/spec/1.2/spec.html#content//
1073. https://yaml.org/spec/1.2/spec.html#line prefix//
1074. https://yaml.org/spec/1.2/spec.html#line break//
1075. https://yaml.org/spec/1.2/spec.html#s-line-prefix(n,c)
1076. https://yaml.org/spec/1.2/spec.html#s-indent(n)
1077. https://yaml.org/spec/1.2/spec.html#b-as-line-feed
1078. https://yaml.org/spec/1.2/spec.html#style/scalar/
1079. https://yaml.org/spec/1.2/spec.html#l-empty(n,c)
1080. https://yaml.org/spec/1.2/spec.html#line break//
1081. https://yaml.org/spec/1.2/spec.html#empty line//
1082. https://yaml.org/spec/1.2/spec.html#line break//
1083. https://yaml.org/spec/1.2/spec.html#content//
1084. https://yaml.org/spec/1.2/spec.html#b-non-content
1085. https://yaml.org/spec/1.2/spec.html#l-empty(n,c)
1086. https://yaml.org/spec/1.2/spec.html#empty line//
1087. https://yaml.org/spec/1.2/spec.html#line break//
1088. https://yaml.org/spec/1.2/spec.html#space//
1089. https://yaml.org/spec/1.2/spec.html#b-break
1090. https://yaml.org/spec/1.2/spec.html#empty line//
1091. https://yaml.org/spec/1.2/spec.html#line break//
1092. https://yaml.org/spec/1.2/spec.html#b-l-trimmed(n,c)
1093. https://yaml.org/spec/1.2/spec.html#b-as-space
1094. https://yaml.org/spec/1.2/spec.html#b-l-trimmed(n,c)
1095. https://yaml.org/spec/1.2/spec.html#b-as-space
1096. https://yaml.org/spec/1.2/spec.html#style/block/folded
1097. https://yaml.org/spec/1.2/spec.html#style/flow/scalar
1098. https://yaml.org/spec/1.2/spec.html#style/block/folded
1099. https://yaml.org/spec/1.2/spec.html#line break//
1100. https://yaml.org/spec/1.2/spec.html#empty line//
1101. https://yaml.org/spec/1.2/spec.html#chomping//
1102. https://yaml.org/spec/1.2/spec.html#line break//
1103. https://yaml.org/spec/1.2/spec.html#space/white/
1104. https://yaml.org/spec/1.2/spec.html#more-indented//
1105. https://yaml.org/spec/1.2/spec.html#space/white/
1106. https://yaml.org/spec/1.2/spec.html#empty line//
1107. https://yaml.org/spec/1.2/spec.html#more-indented//
1108. https://yaml.org/spec/1.2/spec.html#b-l-folded(n,c)
1109. https://yaml.org/spec/1.2/spec.html#style/flow/
1110. https://yaml.org/spec/1.2/spec.html#style/flow/
1111. https://yaml.org/spec/1.2/spec.html#indicator//
1112. https://yaml.org/spec/1.2/spec.html#space/indentation/
1113. https://yaml.org/spec/1.2/spec.html#presentation/detail/
1114. https://yaml.org/spec/1.2/spec.html#content//
1115. https://yaml.org/spec/1.2/spec.html#line break//
1116. https://yaml.org/spec/1.2/spec.html#empty line//
1117. https://yaml.org/spec/1.2/spec.html#more-indented//
1118. https://yaml.org/spec/1.2/spec.html#content//
1119. https://yaml.org/spec/1.2/spec.html#s-separate-in-line
1120. https://yaml.org/spec/1.2/spec.html#b-l-folded(n,c)
1121. https://yaml.org/spec/1.2/spec.html#s-flow-line-prefix(n)
1122. https://yaml.org/spec/1.2/spec.html#s-flow-folded(n)
1123. https://yaml.org/spec/1.2/spec.html#presentation/detail/
1124. https://yaml.org/spec/1.2/spec.html#content//
1125. https://yaml.org/spec/1.2/spec.html#space/separation/
1126. https://yaml.org/spec/1.2/spec.html#space/white/
1127. https://yaml.org/spec/1.2/spec.html#JSON compatibility//
1128. https://yaml.org/spec/1.2/spec.html#processor//
1129. https://yaml.org/spec/1.2/spec.html#line break//
1130. https://yaml.org/spec/1.2/spec.html#stream//
1131. https://yaml.org/spec/1.2/spec.html#processor//
1132. https://yaml.org/spec/1.2/spec.html#stream//
1133. https://yaml.org/spec/1.2/spec.html#line break//
1134. https://yaml.org/spec/1.2/spec.html#c-comment
1135. https://yaml.org/spec/1.2/spec.html#nb-char
1136. https://yaml.org/spec/1.2/spec.html#b-non-content
1137. https://yaml.org/spec/1.2/spec.html#s-separate-in-line
1138. https://yaml.org/spec/1.2/spec.html#c-nb-comment-text
1139. https://yaml.org/spec/1.2/spec.html#b-comment
1140. https://yaml.org/spec/1.2/spec.html#c-nb-comment-text
1141. https://yaml.org/spec/1.2/spec.html#b-comment
1142. https://yaml.org/spec/1.2/spec.html#s-b-comment
1143. https://yaml.org/spec/1.2/spec.html#scalar//
1144. https://yaml.org/spec/1.2/spec.html#space/indentation/
1145. https://yaml.org/spec/1.2/spec.html#scalar//
1146. https://yaml.org/spec/1.2/spec.html#space/white/
1147. https://yaml.org/spec/1.2/spec.html#s-separate-in-line
1148. https://yaml.org/spec/1.2/spec.html#c-nb-comment-text
1149. https://yaml.org/spec/1.2/spec.html#b-comment
1150. https://yaml.org/spec/1.2/spec.html#s-b-comment
1151. https://yaml.org/spec/1.2/spec.html#l-comment
1152. https://yaml.org/spec/1.2/spec.html#block scalar header//
1153. https://yaml.org/spec/1.2/spec.html#s-b-comment
1154. https://yaml.org/spec/1.2/spec.html#l-comment
1155. https://yaml.org/spec/1.2/spec.html#s-b-comment
1156. https://yaml.org/spec/1.2/spec.html#l-comment
1157. https://yaml.org/spec/1.2/spec.html#s-l-comments
1158. https://yaml.org/spec/1.2/spec.html#key/implicit/
1159. https://yaml.org/spec/1.2/spec.html#comment//
1160. https://yaml.org/spec/1.2/spec.html#space/indentation/
1161. https://yaml.org/spec/1.2/spec.html#comment//
1162. https://yaml.org/spec/1.2/spec.html#s-separate-lines(n)
1163. https://yaml.org/spec/1.2/spec.html#s-separate-lines(n)
1164. https://yaml.org/spec/1.2/spec.html#s-separate-lines(n)
1165. https://yaml.org/spec/1.2/spec.html#s-separate-lines(n)
1166. https://yaml.org/spec/1.2/spec.html#s-separate-in-line
1167. https://yaml.org/spec/1.2/spec.html#s-separate-in-line
1168. https://yaml.org/spec/1.2/spec.html#s-l-comments
1169. https://yaml.org/spec/1.2/spec.html#s-flow-line-prefix(n)
1170. https://yaml.org/spec/1.2/spec.html#s-separate-in-line
1171. https://yaml.org/spec/1.2/spec.html#s-separate-in-line
1172. https://yaml.org/spec/1.2/spec.html#s-separate-lines(n)
1173. https://yaml.org/spec/1.2/spec.html#s-indent(n)
1174. https://yaml.org/spec/1.2/spec.html#processor//
1175. https://yaml.org/spec/1.2/spec.html#directive/YAML/
1176. https://yaml.org/spec/1.2/spec.html#directive/TAG/
1177. https://yaml.org/spec/1.2/spec.html#presentation/detail/
1178. https://yaml.org/spec/1.2/spec.html#content//
1179. https://yaml.org/spec/1.2/spec.html#c-directive
1180. https://yaml.org/spec/1.2/spec.html#ns-yaml-directive
1181. https://yaml.org/spec/1.2/spec.html#ns-tag-directive
1182. https://yaml.org/spec/1.2/spec.html#ns-reserved-directive
1183. https://yaml.org/spec/1.2/spec.html#s-l-comments
1184. https://yaml.org/spec/1.2/spec.html#space/indentation/
1185. https://yaml.org/spec/1.2/spec.html#processor//
1186. https://yaml.org/spec/1.2/spec.html#ns-directive-name
1187. https://yaml.org/spec/1.2/spec.html#s-separate-in-line
1188. https://yaml.org/spec/1.2/spec.html#ns-directive-parameter
1189. https://yaml.org/spec/1.2/spec.html#ns-char
1190. https://yaml.org/spec/1.2/spec.html#ns-char
1191. https://yaml.org/spec/1.2/spec.html#ns-reserved-directive
1192. https://yaml.org/spec/1.2/spec.html#ns-directive-name
1193. https://yaml.org/spec/1.2/spec.html#ns-directive-parameter
1194. https://yaml.org/spec/1.2/spec.html#document//
1195. https://yaml.org/spec/1.2/spec.html#processor//
1196. https://yaml.org/spec/1.2/spec.html#document//
1197. https://yaml.org/spec/1.2/spec.html#document//
1198. https://yaml.org/spec/1.2/spec.html#document//
1199. https://yaml.org/spec/1.2/spec.html#document//
1200. https://yaml.org/spec/1.2/spec.html#document//
1201. https://yaml.org/spec/1.2/spec.html#processor//
1202. https://yaml.org/spec/1.2/spec.html#document//
1203. https://yaml.org/spec/1.2/spec.html#processor//
1204. https://yaml.org/spec/1.2/spec.html#document//
1205. https://yaml.org/spec/1.2/spec.html#line break/non-ASCII/
1206. https://yaml.org/spec/1.2/spec.html#non-ASCII line breaks
1207. https://yaml.org/spec/1.2/spec.html#s-separate-in-line
1208. https://yaml.org/spec/1.2/spec.html#ns-yaml-version
1209. https://yaml.org/spec/1.2/spec.html#ns-dec-digit
1210. https://yaml.org/spec/1.2/spec.html#ns-dec-digit
1211. https://yaml.org/spec/1.2/spec.html#ns-yaml-directive
1212. https://yaml.org/spec/1.2/spec.html#ns-yaml-version
1213. https://yaml.org/spec/1.2/spec.html#tag/shorthand/
1214. https://yaml.org/spec/1.2/spec.html#tag//
1215. https://yaml.org/spec/1.2/spec.html#tag/handle/
1216. https://yaml.org/spec/1.2/spec.html#tag/prefix/
1217. https://yaml.org/spec/1.2/spec.html#tag//
1218. https://yaml.org/spec/1.2/spec.html#s-separate-in-line
1219. https://yaml.org/spec/1.2/spec.html#c-tag-handle
1220. https://yaml.org/spec/1.2/spec.html#s-separate-in-line
1221. https://yaml.org/spec/1.2/spec.html#ns-tag-prefix
1222. https://yaml.org/spec/1.2/spec.html#ns-tag-directive
1223. https://yaml.org/spec/1.2/spec.html#c-tag-handle
1224. https://yaml.org/spec/1.2/spec.html#ns-tag-prefix
1225. https://yaml.org/spec/1.2/spec.html#tag/handle/
1226. https://yaml.org/spec/1.2/spec.html#tag/prefix/
1227. https://yaml.org/spec/1.2/spec.html#tag/shorthand/
1228. https://yaml.org/spec/1.2/spec.html#c-named-tag-handle
1229. https://yaml.org/spec/1.2/spec.html#c-secondary-tag-handle
1230. https://yaml.org/spec/1.2/spec.html#c-primary-tag-handle
1231. https://yaml.org/spec/1.2/spec.html#! tag indicator/! local tag/
1232. https://yaml.org/spec/1.2/spec.html#tag/shorthand/
1233. https://yaml.org/spec/1.2/spec.html#tag/local/
1234. https://yaml.org/spec/1.2/spec.html#tag/local/
1235. https://yaml.org/spec/1.2/spec.html#tag/global/
1236. https://yaml.org/spec/1.2/spec.html#c-tag
1237. https://yaml.org/spec/1.2/spec.html#c-primary-tag-handle
1238. https://yaml.org/spec/1.2/spec.html#tag/repository/
1239. https://yaml.org/spec/1.2/spec.html#c-tag
1240. https://yaml.org/spec/1.2/spec.html#c-tag
1241. https://yaml.org/spec/1.2/spec.html#c-secondary-tag-handle
1242. https://yaml.org/spec/1.2/spec.html#tag/shorthand/
1243. https://yaml.org/spec/1.2/spec.html#presentation/detail/
1244. https://yaml.org/spec/1.2/spec.html#content//
1245. https://yaml.org/spec/1.2/spec.html#processor//
1246. https://yaml.org/spec/1.2/spec.html#parse//
1247. https://yaml.org/spec/1.2/spec.html#c-tag
1248. https://yaml.org/spec/1.2/spec.html#ns-word-char
1249. https://yaml.org/spec/1.2/spec.html#c-tag
1250. https://yaml.org/spec/1.2/spec.html#c-named-tag-handle
1251. https://yaml.org/spec/1.2/spec.html#c-ns-local-tag-prefix
1252. https://yaml.org/spec/1.2/spec.html#ns-global-tag-prefix
1253. https://yaml.org/spec/1.2/spec.html#! tag indicator/! local tag/
1254. https://yaml.org/spec/1.2/spec.html#tag/shorthand/
1255. https://yaml.org/spec/1.2/spec.html#tag/handle/
1256. https://yaml.org/spec/1.2/spec.html#tag/local/
1257. https://yaml.org/spec/1.2/spec.html#tag//
1258. https://yaml.org/spec/1.2/spec.html#application//
1259. https://yaml.org/spec/1.2/spec.html#document//
1260. https://yaml.org/spec/1.2/spec.html#stream//
1261. https://yaml.org/spec/1.2/spec.html#tag/local/
1262. https://yaml.org/spec/1.2/spec.html#c-tag
1263. https://yaml.org/spec/1.2/spec.html#ns-uri-char
1264. https://yaml.org/spec/1.2/spec.html#c-ns-local-tag-prefix
1265. https://yaml.org/spec/1.2/spec.html#! tag indicator/! local tag/
1266. https://yaml.org/spec/1.2/spec.html#tag/shorthand/
1267. https://yaml.org/spec/1.2/spec.html#tag/handle/
1268. https://yaml.org/spec/1.2/spec.html#application//
1269. https://yaml.org/spec/1.2/spec.html#document//
1270. https://yaml.org/spec/1.2/spec.html#stream//
1271. https://yaml.org/spec/1.2/spec.html#tag/global/
1272. https://yaml.org/spec/1.2/spec.html#ns-tag-char
1273. https://yaml.org/spec/1.2/spec.html#ns-uri-char
1274. https://yaml.org/spec/1.2/spec.html#ns-global-tag-prefix
1275. https://yaml.org/spec/1.2/spec.html#node//
1276. https://yaml.org/spec/1.2/spec.html#anchor//
1277. https://yaml.org/spec/1.2/spec.html#tag//
1278. https://yaml.org/spec/1.2/spec.html#content//
1279. https://yaml.org/spec/1.2/spec.html#content//
1280. https://yaml.org/spec/1.2/spec.html#c-ns-tag-property
1281. https://yaml.org/spec/1.2/spec.html#s-separate(n,c)
1282. https://yaml.org/spec/1.2/spec.html#c-ns-anchor-property
1283. https://yaml.org/spec/1.2/spec.html#c-ns-anchor-property
1284. https://yaml.org/spec/1.2/spec.html#s-separate(n,c)
1285. https://yaml.org/spec/1.2/spec.html#c-ns-tag-property
1286. https://yaml.org/spec/1.2/spec.html#c-ns-properties(n,c)
1287. https://yaml.org/spec/1.2/spec.html#c-ns-anchor-property
1288. https://yaml.org/spec/1.2/spec.html#c-ns-tag-property
1289. https://yaml.org/spec/1.2/spec.html#native data structure//
1290. https://yaml.org/spec/1.2/spec.html#present//
1291. https://yaml.org/spec/1.2/spec.html#node//
1292. https://yaml.org/spec/1.2/spec.html#c-verbatim-tag
1293. https://yaml.org/spec/1.2/spec.html#c-ns-shorthand-tag
1294. https://yaml.org/spec/1.2/spec.html#c-non-specific-tag
1295. https://yaml.org/spec/1.2/spec.html#processor//
1296. https://yaml.org/spec/1.2/spec.html#application//
1297. https://yaml.org/spec/1.2/spec.html#tag/resolution/
1298. https://yaml.org/spec/1.2/spec.html#! tag indicator/! local tag/
1299. https://yaml.org/spec/1.2/spec.html#tag/local/
1300. https://yaml.org/spec/1.2/spec.html#tag/global/
1301. https://yaml.org/spec/1.2/spec.html#c-tag
1302. https://yaml.org/spec/1.2/spec.html#ns-uri-char
1303. https://yaml.org/spec/1.2/spec.html#c-verbatim-tag
1304. https://yaml.org/spec/1.2/spec.html#tag/handle/
1305. https://yaml.org/spec/1.2/spec.html#tag/handle/
1306. https://yaml.org/spec/1.2/spec.html#tag/prefix/
1307. https://yaml.org/spec/1.2/spec.html#directive/TAG/
1308. https://yaml.org/spec/1.2/spec.html#parse//
1309. https://yaml.org/spec/1.2/spec.html#tag//
1310. https://yaml.org/spec/1.2/spec.html#tag/prefix/
1311. https://yaml.org/spec/1.2/spec.html#! tag indicator/! local tag/
1312. https://yaml.org/spec/1.2/spec.html#tag/local/
1313. https://yaml.org/spec/1.2/spec.html#tag/global/
1314. https://yaml.org/spec/1.2/spec.html#tag/handle/
1315. https://yaml.org/spec/1.2/spec.html#presentation/detail/
1316. https://yaml.org/spec/1.2/spec.html#content//
1317. https://yaml.org/spec/1.2/spec.html#tag/handle/
1318. https://yaml.org/spec/1.2/spec.html#parse//
1319. https://yaml.org/spec/1.2/spec.html#! tag indicator/!…! named handle/
1320. https://yaml.org/spec/1.2/spec.html#tag/handle/named
1321. https://yaml.org/spec/1.2/spec.html#[ start flow sequence//
1322. https://yaml.org/spec/1.2/spec.html#] end flow sequence//
1323. https://yaml.org/spec/1.2/spec.html#{ start flow mapping//
1324. https://yaml.org/spec/1.2/spec.html#} end flow mapping//
1325. https://yaml.org/spec/1.2/spec.html#, end flow entry//
1326. https://yaml.org/spec/1.2/spec.html#style/flow/collection
1327. https://yaml.org/spec/1.2/spec.html#% escaping in URI//
1328. https://yaml.org/spec/1.2/spec.html#% escaping in URI//
1329. http://www.ietf.org/rfc/rfc2396.txt
1330. https://yaml.org/spec/1.2/spec.html#c-tag-handle
1331. https://yaml.org/spec/1.2/spec.html#ns-tag-char
1332. https://yaml.org/spec/1.2/spec.html#c-ns-shorthand-tag
1333. https://yaml.org/spec/1.2/spec.html#node//
1334. https://yaml.org/spec/1.2/spec.html#tag/non-specific/
1335. https://yaml.org/spec/1.2/spec.html#tag/resolution/
1336. https://yaml.org/spec/1.2/spec.html#tag/specific/
1337. https://yaml.org/spec/1.2/spec.html#tag/non-specific/
1338. https://yaml.org/spec/1.2/spec.html#! tag indicator/! non-specific tag/
1339. https://yaml.org/spec/1.2/spec.html#style/flow/plain
1340. https://yaml.org/spec/1.2/spec.html#? non-specific tag//
1341. https://yaml.org/spec/1.2/spec.html#node//
1342. https://yaml.org/spec/1.2/spec.html#style//
1343. https://yaml.org/spec/1.2/spec.html#content//
1344. https://yaml.org/spec/1.2/spec.html#! tag indicator/! non-specific tag/
1345. https://yaml.org/spec/1.2/spec.html#tag/resolution/convention
1346. https://yaml.org/spec/1.2/spec.html#tag/resolution/
1347. https://yaml.org/spec/1.2/spec.html#node//
1348. https://yaml.org/spec/1.2/spec.html#kind//
1349. https://yaml.org/spec/1.2/spec.html#? non-specific tag//
1350. https://yaml.org/spec/1.2/spec.html#c-tag
1351. https://yaml.org/spec/1.2/spec.html#c-non-specific-tag
1352. https://yaml.org/spec/1.2/spec.html#node//
1353. https://yaml.org/spec/1.2/spec.html#alias//
1354. https://yaml.org/spec/1.2/spec.html#node//
1355. https://yaml.org/spec/1.2/spec.html#node//
1356. https://yaml.org/spec/1.2/spec.html#alias//
1357. https://yaml.org/spec/1.2/spec.html#node//
1358. https://yaml.org/spec/1.2/spec.html#c-anchor
1359. https://yaml.org/spec/1.2/spec.html#ns-anchor-name
1360. https://yaml.org/spec/1.2/spec.html#serialization/detail/
1361. https://yaml.org/spec/1.2/spec.html#serialization//
1362. https://yaml.org/spec/1.2/spec.html#representation//
1363. https://yaml.org/spec/1.2/spec.html#content//
1364. https://yaml.org/spec/1.2/spec.html#processor//
1365. https://yaml.org/spec/1.2/spec.html#representation//
1366. https://yaml.org/spec/1.2/spec.html#compose//
1367. https://yaml.org/spec/1.2/spec.html#[ start flow sequence//
1368. https://yaml.org/spec/1.2/spec.html#] end flow sequence//
1369. https://yaml.org/spec/1.2/spec.html#{ start flow mapping//
1370. https://yaml.org/spec/1.2/spec.html#} end flow mapping//
1371. https://yaml.org/spec/1.2/spec.html#, end flow entry//
1372. https://yaml.org/spec/1.2/spec.html#style/flow/collection
1373. https://yaml.org/spec/1.2/spec.html#ns-char
1374. https://yaml.org/spec/1.2/spec.html#c-flow-indicator
1375. https://yaml.org/spec/1.2/spec.html#ns-anchor-char
1376. https://yaml.org/spec/1.2/spec.html#c-ns-anchor-property
1377. https://yaml.org/spec/1.2/spec.html#ns-anchor-name
1378. https://yaml.org/spec/1.2/spec.html#line folding//
1379. https://yaml.org/spec/1.2/spec.html#tag//
1380. https://yaml.org/spec/1.2/spec.html#construct//
1381. https://yaml.org/spec/1.2/spec.html#native data structure//
1382. https://yaml.org/spec/1.2/spec.html#anchor//
1383. https://yaml.org/spec/1.2/spec.html#alias//
1384. https://yaml.org/spec/1.2/spec.html#construct//
1385. https://yaml.org/spec/1.2/spec.html#serialize//
1386. https://yaml.org/spec/1.2/spec.html#present//
1387. https://yaml.org/spec/1.2/spec.html#node//
1388. https://yaml.org/spec/1.2/spec.html#anchor//
1389. https://yaml.org/spec/1.2/spec.html#present//
1390. https://yaml.org/spec/1.2/spec.html#node//
1391. https://yaml.org/spec/1.2/spec.html#anchor//
1392. https://yaml.org/spec/1.2/spec.html#anchor//
1393. https://yaml.org/spec/1.2/spec.html#document//
1394. https://yaml.org/spec/1.2/spec.html#anchor//
1395. https://yaml.org/spec/1.2/spec.html#node/property/
1396. https://yaml.org/spec/1.2/spec.html#content//
1397. https://yaml.org/spec/1.2/spec.html#node//
1398. https://yaml.org/spec/1.2/spec.html#c-alias
1399. https://yaml.org/spec/1.2/spec.html#ns-anchor-name
1400. https://yaml.org/spec/1.2/spec.html#c-ns-alias-node
1401. https://yaml.org/spec/1.2/spec.html#ns-anchor-name
1402. https://yaml.org/spec/1.2/spec.html#content//
1403. https://yaml.org/spec/1.2/spec.html#node//
1404. https://yaml.org/spec/1.2/spec.html#content//
1405. https://yaml.org/spec/1.2/spec.html#style/flow/plain
1406. https://yaml.org/spec/1.2/spec.html#node//
1407. https://yaml.org/spec/1.2/spec.html#tag/repository/null
1408. https://yaml.org/spec/1.2/spec.html#scalar//
1409. https://yaml.org/spec/1.2/spec.html#stream//
1410. https://yaml.org/spec/1.2/spec.html#e-scalar
1411. https://yaml.org/spec/1.2/spec.html#node/property/
1412. https://yaml.org/spec/1.2/spec.html#content//
1413. https://yaml.org/spec/1.2/spec.html#e-scalar
1414. https://yaml.org/spec/1.2/spec.html#e-node
1415. https://yaml.org/spec/1.2/spec.html#style/flow/double-quoted
1416. https://yaml.org/spec/1.2/spec.html#style/flow/single-quoted
1417. https://yaml.org/spec/1.2/spec.html#style/flow/plain
1418. https://yaml.org/spec/1.2/spec.html#style/scalar/
1419. https://yaml.org/spec/1.2/spec.html#presentation/detail/
1420. https://yaml.org/spec/1.2/spec.html#content//
1421. https://yaml.org/spec/1.2/spec.html#style/flow/plain
1422. https://yaml.org/spec/1.2/spec.html#tag/resolution/
1423. https://yaml.org/spec/1.2/spec.html#style//
1424. https://yaml.org/spec/1.2/spec.html#\ escaping in double-quoted scalars//
1425. https://yaml.org/spec/1.2/spec.html#escaping/in double-quoted scalars/
1426. https://yaml.org/spec/1.2/spec.html#\ escaping in double-quoted scalars//
1427. https://yaml.org/spec/1.2/spec.html#c-ns-esc-char
1428. https://yaml.org/spec/1.2/spec.html#nb-json
1429. https://yaml.org/spec/1.2/spec.html#c-escape
1430. https://yaml.org/spec/1.2/spec.html#c-double-quote
1431. https://yaml.org/spec/1.2/spec.html#nb-double-char
1432. https://yaml.org/spec/1.2/spec.html#s-white
1433. https://yaml.org/spec/1.2/spec.html#key/implicit/
1434. https://yaml.org/spec/1.2/spec.html#c-double-quote
1435. https://yaml.org/spec/1.2/spec.html#nb-double-text(n,c)
1436. https://yaml.org/spec/1.2/spec.html#c-double-quote
1437. https://yaml.org/spec/1.2/spec.html#nb-double-multi-line(n)
1438. https://yaml.org/spec/1.2/spec.html#nb-double-multi-line(n)
1439. https://yaml.org/spec/1.2/spec.html#nb-double-one-line
1440. https://yaml.org/spec/1.2/spec.html#nb-double-one-line
1441. https://yaml.org/spec/1.2/spec.html#nb-double-char
1442. https://yaml.org/spec/1.2/spec.html#nb-double-one-line
1443. https://yaml.org/spec/1.2/spec.html#c-double-quoted(n,c)
1444. https://yaml.org/spec/1.2/spec.html#line break//
1445. https://yaml.org/spec/1.2/spec.html#line folding/flow/
1446. https://yaml.org/spec/1.2/spec.html#space/white/
1447. https://yaml.org/spec/1.2/spec.html#line break//
1448. https://yaml.org/spec/1.2/spec.html#line break//
1449. https://yaml.org/spec/1.2/spec.html#content//
1450. https://yaml.org/spec/1.2/spec.html#space/white/
1451. https://yaml.org/spec/1.2/spec.html#escaping/in double-quoted scalars/
1452. https://yaml.org/spec/1.2/spec.html#space/white/
1453. https://yaml.org/spec/1.2/spec.html#s-white
1454. https://yaml.org/spec/1.2/spec.html#c-escape
1455. https://yaml.org/spec/1.2/spec.html#b-non-content
1456. https://yaml.org/spec/1.2/spec.html#l-empty(n,c)
1457. https://yaml.org/spec/1.2/spec.html#s-flow-line-prefix(n)
1458. https://yaml.org/spec/1.2/spec.html#s-double-escaped(n)
1459. https://yaml.org/spec/1.2/spec.html#s-flow-folded(n)
1460. https://yaml.org/spec/1.2/spec.html#s-flow-folded(n)
1461. https://yaml.org/spec/1.2/spec.html#s-double-escaped(n)
1462. https://yaml.org/spec/1.2/spec.html#space/white/
1463. https://yaml.org/spec/1.2/spec.html#content//
1464. https://yaml.org/spec/1.2/spec.html#space/white/
1465. https://yaml.org/spec/1.2/spec.html#line folding//
1466. https://yaml.org/spec/1.2/spec.html#s-white
1467. https://yaml.org/spec/1.2/spec.html#ns-double-char
1468. https://yaml.org/spec/1.2/spec.html#s-double-break(n)
1469. https://yaml.org/spec/1.2/spec.html#ns-double-char
1470. https://yaml.org/spec/1.2/spec.html#nb-ns-double-in-line
1471. https://yaml.org/spec/1.2/spec.html#s-double-next-line(n)
1472. https://yaml.org/spec/1.2/spec.html#s-white
1473. https://yaml.org/spec/1.2/spec.html#nb-ns-double-in-line
1474. https://yaml.org/spec/1.2/spec.html#s-double-next-line(n)
1475. https://yaml.org/spec/1.2/spec.html#s-white
1476. https://yaml.org/spec/1.2/spec.html#nb-ns-double-in-line
1477. https://yaml.org/spec/1.2/spec.html#s-double-next-line(n)
1478. https://yaml.org/spec/1.2/spec.html#printable character//
1479. https://yaml.org/spec/1.2/spec.html#space//
1480. https://yaml.org/spec/1.2/spec.html#space/white/
1481. https://yaml.org/spec/1.2/spec.html#c-single-quote
1482. https://yaml.org/spec/1.2/spec.html#c-single-quote
1483. https://yaml.org/spec/1.2/spec.html#c-quoted-quote
1484. https://yaml.org/spec/1.2/spec.html#nb-json
1485. https://yaml.org/spec/1.2/spec.html#c-single-quote
1486. https://yaml.org/spec/1.2/spec.html#nb-single-char
1487. https://yaml.org/spec/1.2/spec.html#s-white
1488. https://yaml.org/spec/1.2/spec.html#c-quoted-quote
1489. https://yaml.org/spec/1.2/spec.html#key/implicit/
1490. https://yaml.org/spec/1.2/spec.html#c-single-quote
1491. https://yaml.org/spec/1.2/spec.html#nb-single-text(n,c)
1492. https://yaml.org/spec/1.2/spec.html#c-single-quote
1493. https://yaml.org/spec/1.2/spec.html#nb-single-multi-line(n)
1494. https://yaml.org/spec/1.2/spec.html#nb-single-multi-line(n)
1495. https://yaml.org/spec/1.2/spec.html#nb-single-one-line
1496. https://yaml.org/spec/1.2/spec.html#nb-single-one-line
1497. https://yaml.org/spec/1.2/spec.html#nb-single-char
1498. https://yaml.org/spec/1.2/spec.html#nb-single-one-line
1499. https://yaml.org/spec/1.2/spec.html#c-single-quoted(n,c)
1500. https://yaml.org/spec/1.2/spec.html#space/white/
1501. https://yaml.org/spec/1.2/spec.html#content//
1502. https://yaml.org/spec/1.2/spec.html#space/white/
1503. https://yaml.org/spec/1.2/spec.html#line folding//
1504. https://yaml.org/spec/1.2/spec.html#s-white
1505. https://yaml.org/spec/1.2/spec.html#ns-single-char
1506. https://yaml.org/spec/1.2/spec.html#s-flow-folded(n)
1507. https://yaml.org/spec/1.2/spec.html#ns-single-char
1508. https://yaml.org/spec/1.2/spec.html#nb-ns-single-in-line
1509. https://yaml.org/spec/1.2/spec.html#s-single-next-line(n)
1510. https://yaml.org/spec/1.2/spec.html#s-white
1511. https://yaml.org/spec/1.2/spec.html#nb-ns-single-in-line
1512. https://yaml.org/spec/1.2/spec.html#s-single-next-line(n)
1513. https://yaml.org/spec/1.2/spec.html#s-white
1514. https://yaml.org/spec/1.2/spec.html#nb-ns-single-in-line
1515. https://yaml.org/spec/1.2/spec.html#s-single-next-line(n)
1516. https://yaml.org/spec/1.2/spec.html#indicator//
1517. https://yaml.org/spec/1.2/spec.html#context//
1518. https://yaml.org/spec/1.2/spec.html#style//
1519. https://yaml.org/spec/1.2/spec.html#space/white/
1520. https://yaml.org/spec/1.2/spec.html#space//
1521. https://yaml.org/spec/1.2/spec.html#space/white/
1522. https://yaml.org/spec/1.2/spec.html#indicator//
1523. https://yaml.org/spec/1.2/spec.html#: mapping value//
1524. https://yaml.org/spec/1.2/spec.html#? mapping key//
1525. https://yaml.org/spec/1.2/spec.html#- block sequence entry//
1526. https://yaml.org/spec/1.2/spec.html#indicator//
1527. https://yaml.org/spec/1.2/spec.html#space/white/
1528. https://yaml.org/spec/1.2/spec.html#ns-char
1529. https://yaml.org/spec/1.2/spec.html#c-indicator
1530. https://yaml.org/spec/1.2/spec.html#c-mapping-key
1531. https://yaml.org/spec/1.2/spec.html#c-mapping-value
1532. https://yaml.org/spec/1.2/spec.html#c-sequence-entry
1533. https://yaml.org/spec/1.2/spec.html#ns-plain-safe(c)
1534. https://yaml.org/spec/1.2/spec.html#: mapping value//
1535. https://yaml.org/spec/1.2/spec.html## comment//
1536. https://yaml.org/spec/1.2/spec.html#mapping//
1537. https://yaml.org/spec/1.2/spec.html#key: value pair//
1538. https://yaml.org/spec/1.2/spec.html#comment//
1539. https://yaml.org/spec/1.2/spec.html#style/flow/collection
1540. https://yaml.org/spec/1.2/spec.html#key/implicit/
1541. https://yaml.org/spec/1.2/spec.html#[ start flow sequence//
1542. https://yaml.org/spec/1.2/spec.html#] end flow sequence//
1543. https://yaml.org/spec/1.2/spec.html#{ start flow mapping//
1544. https://yaml.org/spec/1.2/spec.html#} end flow mapping//
1545. https://yaml.org/spec/1.2/spec.html#, end flow entry//
1546. https://yaml.org/spec/1.2/spec.html#style/flow/collection
1547. https://yaml.org/spec/1.2/spec.html#ns-plain-safe-out
1548. https://yaml.org/spec/1.2/spec.html#ns-plain-safe-in
1549. https://yaml.org/spec/1.2/spec.html#ns-plain-safe-out
1550. https://yaml.org/spec/1.2/spec.html#ns-plain-safe-in
1551. https://yaml.org/spec/1.2/spec.html#ns-char
1552. https://yaml.org/spec/1.2/spec.html#ns-char
1553. https://yaml.org/spec/1.2/spec.html#c-flow-indicator
1554. https://yaml.org/spec/1.2/spec.html#ns-plain-safe(c)
1555. https://yaml.org/spec/1.2/spec.html#c-mapping-value
1556. https://yaml.org/spec/1.2/spec.html#c-comment
1557. https://yaml.org/spec/1.2/spec.html#ns-char
1558. https://yaml.org/spec/1.2/spec.html#c-comment
1559. https://yaml.org/spec/1.2/spec.html#c-mapping-value
1560. https://yaml.org/spec/1.2/spec.html#ns-plain-safe(c)
1561. https://yaml.org/spec/1.2/spec.html#ns-plain-first(c)
1562. https://yaml.org/spec/1.2/spec.html#ns-plain-char(c)
1563. https://yaml.org/spec/1.2/spec.html#key/implicit/
1564. https://yaml.org/spec/1.2/spec.html#ns-plain-multi-line(n,c)
1565. https://yaml.org/spec/1.2/spec.html#ns-plain-multi-line(n,c)
1566. https://yaml.org/spec/1.2/spec.html#ns-plain-one-line(c)
1567. https://yaml.org/spec/1.2/spec.html#ns-plain-one-line(c)
1568. https://yaml.org/spec/1.2/spec.html#s-white
1569. https://yaml.org/spec/1.2/spec.html#ns-plain-char(c)
1570. https://yaml.org/spec/1.2/spec.html#ns-plain-first(c)
1571. https://yaml.org/spec/1.2/spec.html#nb-ns-plain-in-line(c)
1572. https://yaml.org/spec/1.2/spec.html#ns-plain-one-line(c)
1573. https://yaml.org/spec/1.2/spec.html#space/white/
1574. https://yaml.org/spec/1.2/spec.html#content//
1575. https://yaml.org/spec/1.2/spec.html#space/white/
1576. https://yaml.org/spec/1.2/spec.html#line folding//
1577. https://yaml.org/spec/1.2/spec.html#s-flow-folded(n)
1578. https://yaml.org/spec/1.2/spec.html#ns-plain-char(c)
1579. https://yaml.org/spec/1.2/spec.html#nb-ns-plain-in-line(c)
1580. https://yaml.org/spec/1.2/spec.html#ns-plain-one-line(c)
1581. https://yaml.org/spec/1.2/spec.html#s-ns-plain-next-line(n,c)
1582. https://yaml.org/spec/1.2/spec.html#nb-ns-plain-in-line(c)
1583. https://yaml.org/spec/1.2/spec.html#s-ns-plain-next-line(n,c)
1584. https://yaml.org/spec/1.2/spec.html#style/block/collection
1585. https://yaml.org/spec/1.2/spec.html#context/flow-out/
1586. https://yaml.org/spec/1.2/spec.html#context/flow-in/
1587. https://yaml.org/spec/1.2/spec.html#key/implicit/
1588. https://yaml.org/spec/1.2/spec.html#context/flow-key/
1589. https://yaml.org/spec/1.2/spec.html#context/block-key/
1590. https://yaml.org/spec/1.2/spec.html#node/completely empty/
1591. https://yaml.org/spec/1.2/spec.html#c-sequence-start
1592. https://yaml.org/spec/1.2/spec.html#s-separate(n,c)
1593. https://yaml.org/spec/1.2/spec.html#ns-s-flow-seq-entries(n,c)
1594. https://yaml.org/spec/1.2/spec.html#in-flow(c)
1595. https://yaml.org/spec/1.2/spec.html#ns-s-flow-seq-entries(n,c)
1596. https://yaml.org/spec/1.2/spec.html#c-sequence-end
1597. https://yaml.org/spec/1.2/spec.html#, end flow entry//
1598. https://yaml.org/spec/1.2/spec.html#ns-flow-seq-entry(n,c)
1599. https://yaml.org/spec/1.2/spec.html#s-separate(n,c)
1600. https://yaml.org/spec/1.2/spec.html#c-collect-entry
1601. https://yaml.org/spec/1.2/spec.html#s-separate(n,c)
1602. https://yaml.org/spec/1.2/spec.html#ns-s-flow-seq-entries(n,c)
1603. https://yaml.org/spec/1.2/spec.html#c-sequence-start
1604. https://yaml.org/spec/1.2/spec.html#c-sequence-end
1605. https://yaml.org/spec/1.2/spec.html#ns-flow-seq-entry(n,c)
1606. https://yaml.org/spec/1.2/spec.html#style/flow/
1607. https://yaml.org/spec/1.2/spec.html#style/single key:value pair mapping/
1608. https://yaml.org/spec/1.2/spec.html#mapping//
1609. https://yaml.org/spec/1.2/spec.html#style/single key:value pair mapping/
1610. https://yaml.org/spec/1.2/spec.html#ns-flow-pair(n,c)
1611. https://yaml.org/spec/1.2/spec.html#ns-flow-node(n,c)
1612. https://yaml.org/spec/1.2/spec.html#ns-flow-node(n,c)
1613. https://yaml.org/spec/1.2/spec.html#ns-flow-pair(n,c)
1614. https://yaml.org/spec/1.2/spec.html#c-mapping-start
1615. https://yaml.org/spec/1.2/spec.html#s-separate(n,c)
1616. https://yaml.org/spec/1.2/spec.html#ns-s-flow-map-entries(n,c)
1617. https://yaml.org/spec/1.2/spec.html#in-flow(c)
1618. https://yaml.org/spec/1.2/spec.html#ns-s-flow-map-entries(n,c)
1619. https://yaml.org/spec/1.2/spec.html#c-mapping-end
1620. https://yaml.org/spec/1.2/spec.html#, end flow entry//
1621. https://yaml.org/spec/1.2/spec.html#ns-flow-map-entry(n,c)
1622. https://yaml.org/spec/1.2/spec.html#s-separate(n,c)
1623. https://yaml.org/spec/1.2/spec.html#c-collect-entry
1624. https://yaml.org/spec/1.2/spec.html#s-separate(n,c)
1625. https://yaml.org/spec/1.2/spec.html#ns-s-flow-map-entries(n,c)
1626. https://yaml.org/spec/1.2/spec.html#c-mapping-start
1627. https://yaml.org/spec/1.2/spec.html#c-mapping-end
1628. https://yaml.org/spec/1.2/spec.html#ns-flow-map-entry(n,c)
1629. https://yaml.org/spec/1.2/spec.html#node/completely empty/
1630. https://yaml.org/spec/1.2/spec.html#c-mapping-key
1631. https://yaml.org/spec/1.2/spec.html#s-separate(n,c)
1632. https://yaml.org/spec/1.2/spec.html#ns-flow-map-explicit-entry(n,c)
1633. https://yaml.org/spec/1.2/spec.html#ns-flow-map-implicit-entry(n,c)
1634. https://yaml.org/spec/1.2/spec.html#ns-flow-map-implicit-entry(n,c)
1635. https://yaml.org/spec/1.2/spec.html#e-node
1636. https://yaml.org/spec/1.2/spec.html#e-node
1637. https://yaml.org/spec/1.2/spec.html#ns-flow-map-explicit-entry(n,c)
1638. https://yaml.org/spec/1.2/spec.html#ns-flow-map-implicit-entry(n,c)
1639. https://yaml.org/spec/1.2/spec.html#e-node
1640. https://yaml.org/spec/1.2/spec.html#space/separation/
1641. https://yaml.org/spec/1.2/spec.html#value//
1642. https://yaml.org/spec/1.2/spec.html#space/white/
1643. https://yaml.org/spec/1.2/spec.html#style/flow/plain
1644. https://yaml.org/spec/1.2/spec.html#space/white/
1645. https://yaml.org/spec/1.2/spec.html#style/flow/plain
1646. https://yaml.org/spec/1.2/spec.html#key: value pair//
1647. https://yaml.org/spec/1.2/spec.html#value//
1648. https://yaml.org/spec/1.2/spec.html#node/completely empty/
1649. https://yaml.org/spec/1.2/spec.html#ns-flow-map-yaml-key-entry(n,c)
1650. https://yaml.org/spec/1.2/spec.html#c-ns-flow-map-empty-key-entry(n,c)
1651. https://yaml.org/spec/1.2/spec.html#c-ns-flow-map-json-key-entry(n,c)
1652. https://yaml.org/spec/1.2/spec.html#ns-flow-yaml-node(n,c)
1653. https://yaml.org/spec/1.2/spec.html#s-separate(n,c)
1654. https://yaml.org/spec/1.2/spec.html#c-ns-flow-map-separate-value(n,c)
1655. https://yaml.org/spec/1.2/spec.html#e-node
1656. https://yaml.org/spec/1.2/spec.html#e-node
1657. https://yaml.org/spec/1.2/spec.html#c-ns-flow-map-separate-value(n,c)
1658. https://yaml.org/spec/1.2/spec.html#c-mapping-value
1659. https://yaml.org/spec/1.2/spec.html#ns-plain-safe(c)
1660. https://yaml.org/spec/1.2/spec.html#s-separate(n,c)
1661. https://yaml.org/spec/1.2/spec.html#ns-flow-node(n,c)
1662. https://yaml.org/spec/1.2/spec.html#e-node
1663. https://yaml.org/spec/1.2/spec.html#ns-flow-yaml-node(n,c)
1664. https://yaml.org/spec/1.2/spec.html#e-node
1665. https://yaml.org/spec/1.2/spec.html#c-ns-flow-map-separate-value(n,c)
1666. https://yaml.org/spec/1.2/spec.html#JSON compatibility//
1667. https://yaml.org/spec/1.2/spec.html#key//
1668. https://yaml.org/spec/1.2/spec.html#JSON-like//
1669. https://yaml.org/spec/1.2/spec.html#value//
1670. https://yaml.org/spec/1.2/spec.html#JSON-like//
1671. https://yaml.org/spec/1.2/spec.html#key//
1672. https://yaml.org/spec/1.2/spec.html#indicator//
1673. https://yaml.org/spec/1.2/spec.html#processor//
1674. https://yaml.org/spec/1.2/spec.html#space/separation/
1675. https://yaml.org/spec/1.2/spec.html#value//
1676. https://yaml.org/spec/1.2/spec.html#c-flow-json-node(n,c)
1677. https://yaml.org/spec/1.2/spec.html#s-separate(n,c)
1678. https://yaml.org/spec/1.2/spec.html#c-ns-flow-map-adjacent-value(n,c)
1679. https://yaml.org/spec/1.2/spec.html#e-node
1680. https://yaml.org/spec/1.2/spec.html#c-mapping-value
1681. https://yaml.org/spec/1.2/spec.html#s-separate(n,c)
1682. https://yaml.org/spec/1.2/spec.html#ns-flow-node(n,c)
1683. https://yaml.org/spec/1.2/spec.html#e-node
1684. https://yaml.org/spec/1.2/spec.html#c-flow-json-node(n,c)
1685. https://yaml.org/spec/1.2/spec.html#e-node
1686. https://yaml.org/spec/1.2/spec.html#c-ns-flow-map-adjacent-value(n,c)
1687. https://yaml.org/spec/1.2/spec.html#style/flow/sequence
1688. https://yaml.org/spec/1.2/spec.html#mapping//
1689. https://yaml.org/spec/1.2/spec.html#node/property/
1690. https://yaml.org/spec/1.2/spec.html#mapping//
1691. https://yaml.org/spec/1.2/spec.html#ns-flow-pair(n,c)
1692. https://yaml.org/spec/1.2/spec.html#parse//
1693. https://yaml.org/spec/1.2/spec.html#c-mapping-key
1694. https://yaml.org/spec/1.2/spec.html#s-separate(n,c)
1695. https://yaml.org/spec/1.2/spec.html#ns-flow-map-explicit-entry(n,c)
1696. https://yaml.org/spec/1.2/spec.html#ns-flow-pair-entry(n,c)
1697. https://yaml.org/spec/1.2/spec.html#ns-flow-map-explicit-entry(n,c)
1698. https://yaml.org/spec/1.2/spec.html#parse//
1699. https://yaml.org/spec/1.2/spec.html#key//
1700. https://yaml.org/spec/1.2/spec.html#key//
1701. https://yaml.org/spec/1.2/spec.html#node//
1702. https://yaml.org/spec/1.2/spec.html#key//
1703. https://yaml.org/spec/1.2/spec.html#key//
1704. https://yaml.org/spec/1.2/spec.html#sequence//
1705. https://yaml.org/spec/1.2/spec.html#mapping//
1706. https://yaml.org/spec/1.2/spec.html#parse//
1707. https://yaml.org/spec/1.2/spec.html#ns-flow-pair-yaml-key-entry(n,c)
1708. https://yaml.org/spec/1.2/spec.html#c-ns-flow-map-empty-key-entry(n,c)
1709. https://yaml.org/spec/1.2/spec.html#c-ns-flow-pair-json-key-entry(n,c)
1710. https://yaml.org/spec/1.2/spec.html#ns-s-implicit-yaml-key(c)
1711. https://yaml.org/spec/1.2/spec.html#c-ns-flow-map-separate-value(n,c)
1712. https://yaml.org/spec/1.2/spec.html#c-s-implicit-json-key(c)
1713. https://yaml.org/spec/1.2/spec.html#c-ns-flow-map-adjacent-value(n,c)
1714. https://yaml.org/spec/1.2/spec.html#ns-flow-yaml-node(n,c)
1715. https://yaml.org/spec/1.2/spec.html#s-separate-in-line
1716. https://yaml.org/spec/1.2/spec.html#c-flow-json-node(n,c)
1717. https://yaml.org/spec/1.2/spec.html#s-separate-in-line
1718. https://yaml.org/spec/1.2/spec.html#ns-s-implicit-yaml-key(c)
1719. https://yaml.org/spec/1.2/spec.html#c-s-implicit-json-key(c)
1720. https://yaml.org/spec/1.2/spec.html#e-node
1721. https://yaml.org/spec/1.2/spec.html#style/flow/
1722. https://yaml.org/spec/1.2/spec.html#indicator//
1723. https://yaml.org/spec/1.2/spec.html#style/flow/
1724. https://yaml.org/spec/1.2/spec.html#style/flow/plain
1725. https://yaml.org/spec/1.2/spec.html#style/flow/double-quoted
1726. https://yaml.org/spec/1.2/spec.html#ns-plain(n,c)
1727. https://yaml.org/spec/1.2/spec.html#c-flow-sequence(n,c)
1728. https://yaml.org/spec/1.2/spec.html#c-flow-mapping(n,c)
1729. https://yaml.org/spec/1.2/spec.html#c-single-quoted(n,c)
1730. https://yaml.org/spec/1.2/spec.html#c-double-quoted(n,c)
1731. https://yaml.org/spec/1.2/spec.html#ns-flow-yaml-content(n,c)
1732. https://yaml.org/spec/1.2/spec.html#c-flow-json-content(n,c)
1733. https://yaml.org/spec/1.2/spec.html#c-flow-json-content(n,c)
1734. https://yaml.org/spec/1.2/spec.html#ns-flow-yaml-content(n,c)
1735. https://yaml.org/spec/1.2/spec.html#style/flow/
1736. https://yaml.org/spec/1.2/spec.html#node//
1737. https://yaml.org/spec/1.2/spec.html#node/property/
1738. https://yaml.org/spec/1.2/spec.html#alias//
1739. https://yaml.org/spec/1.2/spec.html#anchor//
1740. https://yaml.org/spec/1.2/spec.html#node/property/
1741. https://yaml.org/spec/1.2/spec.html#c-ns-alias-node
1742. https://yaml.org/spec/1.2/spec.html#ns-flow-yaml-content(n,c)
1743. https://yaml.org/spec/1.2/spec.html#c-ns-properties(n,c)
1744. https://yaml.org/spec/1.2/spec.html#s-separate(n,c)
1745. https://yaml.org/spec/1.2/spec.html#ns-flow-yaml-content(n,c)
1746. https://yaml.org/spec/1.2/spec.html#e-scalar
1747. https://yaml.org/spec/1.2/spec.html#c-ns-properties(n,c)
1748. https://yaml.org/spec/1.2/spec.html#s-separate(n,c)
1749. https://yaml.org/spec/1.2/spec.html#c-flow-json-content(n,c)
1750. https://yaml.org/spec/1.2/spec.html#c-ns-alias-node
1751. https://yaml.org/spec/1.2/spec.html#ns-flow-content(n,c)
1752. https://yaml.org/spec/1.2/spec.html#c-ns-properties(n,c)
1753. https://yaml.org/spec/1.2/spec.html#s-separate(n,c)
1754. https://yaml.org/spec/1.2/spec.html#ns-flow-content(n,c)
1755. https://yaml.org/spec/1.2/spec.html#e-scalar
1756. https://yaml.org/spec/1.2/spec.html#c-flow-json-node(n,c)
1757. https://yaml.org/spec/1.2/spec.html#ns-flow-yaml-node(n,c)
1758. https://yaml.org/spec/1.2/spec.html#space/indentation/
1759. https://yaml.org/spec/1.2/spec.html#indicator//
1760. https://yaml.org/spec/1.2/spec.html#style/block/literal
1761. https://yaml.org/spec/1.2/spec.html#style/block/folded
1762. https://yaml.org/spec/1.2/spec.html#style/block/scalar
1763. https://yaml.org/spec/1.2/spec.html#indicator//
1764. https://yaml.org/spec/1.2/spec.html#content//
1765. https://yaml.org/spec/1.2/spec.html#line break//
1766. https://yaml.org/spec/1.2/spec.html#comment//
1767. https://yaml.org/spec/1.2/spec.html#comment//
1768. https://yaml.org/spec/1.2/spec.html#comment//
1769. https://yaml.org/spec/1.2/spec.html#c-indentation-indicator(m)
1770. https://yaml.org/spec/1.2/spec.html#c-chomping-indicator(t)
1771. https://yaml.org/spec/1.2/spec.html#c-chomping-indicator(t)
1772. https://yaml.org/spec/1.2/spec.html#c-indentation-indicator(m)
1773. https://yaml.org/spec/1.2/spec.html#s-b-comment
1774. https://yaml.org/spec/1.2/spec.html#c-b-block-header(m,t)
1775. https://yaml.org/spec/1.2/spec.html#space/indentation/
1776. https://yaml.org/spec/1.2/spec.html#style/block/scalar
1777. https://yaml.org/spec/1.2/spec.html#empty line//
1778. https://yaml.org/spec/1.2/spec.html#empty line//
1779. https://yaml.org/spec/1.2/spec.html#space//
1780. https://yaml.org/spec/1.2/spec.html#empty line//
1781. https://yaml.org/spec/1.2/spec.html#empty line//
1782. https://yaml.org/spec/1.2/spec.html#space//
1783. https://yaml.org/spec/1.2/spec.html#content//
1784. https://yaml.org/spec/1.2/spec.html#tab//
1785. https://yaml.org/spec/1.2/spec.html## comment//
1786. https://yaml.org/spec/1.2/spec.html#space/indentation/
1787. https://yaml.org/spec/1.2/spec.html#content//
1788. https://yaml.org/spec/1.2/spec.html#space/indentation/
1789. https://yaml.org/spec/1.2/spec.html#content//
1790. https://yaml.org/spec/1.2/spec.html#node//
1791. https://yaml.org/spec/1.2/spec.html#style/block/scalar
1792. https://yaml.org/spec/1.2/spec.html#processor//
1793. https://yaml.org/spec/1.2/spec.html#ns-dec-digit
1794. https://yaml.org/spec/1.2/spec.html#ns-dec-digit
1795. https://yaml.org/spec/1.2/spec.html#c-indentation-indicator(m)
1796. https://yaml.org/spec/1.2/spec.html#s-indent(n)
1797. https://yaml.org/spec/1.2/spec.html#line break//
1798. https://yaml.org/spec/1.2/spec.html#empty line//
1799. https://yaml.org/spec/1.2/spec.html#line break//
1800. https://yaml.org/spec/1.2/spec.html#empty line//
1801. https://yaml.org/spec/1.2/spec.html#scalar//
1802. https://yaml.org/spec/1.2/spec.html#line break//
1803. https://yaml.org/spec/1.2/spec.html#scalar//
1804. https://yaml.org/spec/1.2/spec.html#empty line//
1805. https://yaml.org/spec/1.2/spec.html#scalar//
1806. https://yaml.org/spec/1.2/spec.html#line break//
1807. https://yaml.org/spec/1.2/spec.html#empty line//
1808. https://yaml.org/spec/1.2/spec.html#scalar//
1809. https://yaml.org/spec/1.2/spec.html#line folding//
1810. https://yaml.org/spec/1.2/spec.html#presentation/detail/
1811. https://yaml.org/spec/1.2/spec.html#content//
1812. https://yaml.org/spec/1.2/spec.html#line break//
1813. https://yaml.org/spec/1.2/spec.html#style/block/scalar
1814. https://yaml.org/spec/1.2/spec.html#block scalar header//
1815. https://yaml.org/spec/1.2/spec.html#b-non-content
1816. https://yaml.org/spec/1.2/spec.html#b-as-line-feed
1817. https://yaml.org/spec/1.2/spec.html#b-as-line-feed
1818. https://yaml.org/spec/1.2/spec.html#b-non-content
1819. https://yaml.org/spec/1.2/spec.html#b-as-line-feed
1820. https://yaml.org/spec/1.2/spec.html#empty line//
1821. https://yaml.org/spec/1.2/spec.html#style/block/scalar
1822. https://yaml.org/spec/1.2/spec.html#block scalar header//
1823. https://yaml.org/spec/1.2/spec.html#l-strip-empty(n)
1824. https://yaml.org/spec/1.2/spec.html#l-strip-empty(n)
1825. https://yaml.org/spec/1.2/spec.html#l-keep-empty(n)
1826. https://yaml.org/spec/1.2/spec.html#s-indent(n)
1827. https://yaml.org/spec/1.2/spec.html#b-non-content
1828. https://yaml.org/spec/1.2/spec.html#l-trail-comments(n)
1829. https://yaml.org/spec/1.2/spec.html#l-empty(n,c)
1830. https://yaml.org/spec/1.2/spec.html#l-trail-comments(n)
1831. https://yaml.org/spec/1.2/spec.html#comment//
1832. https://yaml.org/spec/1.2/spec.html#empty line//
1833. https://yaml.org/spec/1.2/spec.html#comment//
1834. https://yaml.org/spec/1.2/spec.html#space/indentation/
1835. https://yaml.org/spec/1.2/spec.html#style/block/scalar
1836. https://yaml.org/spec/1.2/spec.html#comment//
1837. https://yaml.org/spec/1.2/spec.html#space/indentation/
1838. https://yaml.org/spec/1.2/spec.html#comment//
1839. https://yaml.org/spec/1.2/spec.html#s-indent(n)
1840. https://yaml.org/spec/1.2/spec.html#c-nb-comment-text
1841. https://yaml.org/spec/1.2/spec.html#b-comment
1842. https://yaml.org/spec/1.2/spec.html#l-comment
1843. https://yaml.org/spec/1.2/spec.html#l-strip-empty(n)
1844. https://yaml.org/spec/1.2/spec.html#l-keep-empty(n)
1845. https://yaml.org/spec/1.2/spec.html#l-trail-comments(n)
1846. https://yaml.org/spec/1.2/spec.html#style/block/scalar
1847. https://yaml.org/spec/1.2/spec.html#empty line//
1848. https://yaml.org/spec/1.2/spec.html#l-strip-empty(n)
1849. https://yaml.org/spec/1.2/spec.html#l-keep-empty(n)
1850. https://yaml.org/spec/1.2/spec.html#style/scalar/
1851. https://yaml.org/spec/1.2/spec.html#c-literal
1852. https://yaml.org/spec/1.2/spec.html#c-b-block-header(m,t)
1853. https://yaml.org/spec/1.2/spec.html#l-literal-content(n,t)
1854. https://yaml.org/spec/1.2/spec.html#c-l+literal(n)
1855. https://yaml.org/spec/1.2/spec.html#space/indentation/
1856. https://yaml.org/spec/1.2/spec.html#content//
1857. https://yaml.org/spec/1.2/spec.html#space/white/
1858. https://yaml.org/spec/1.2/spec.html#line break//
1859. https://yaml.org/spec/1.2/spec.html#line break/normalization/
1860. https://yaml.org/spec/1.2/spec.html#empty line//
1861. https://yaml.org/spec/1.2/spec.html#style/block/folded
1862. https://yaml.org/spec/1.2/spec.html#line break//
1863. https://yaml.org/spec/1.2/spec.html#empty line//
1864. https://yaml.org/spec/1.2/spec.html#chomping//
1865. https://yaml.org/spec/1.2/spec.html#printable character//
1866. https://yaml.org/spec/1.2/spec.html#l-empty(n,c)
1867. https://yaml.org/spec/1.2/spec.html#s-indent(n)
1868. https://yaml.org/spec/1.2/spec.html#nb-char
1869. https://yaml.org/spec/1.2/spec.html#b-as-line-feed
1870. https://yaml.org/spec/1.2/spec.html#l-nb-literal-text(n)
1871. https://yaml.org/spec/1.2/spec.html#l-nb-literal-text(n)
1872. https://yaml.org/spec/1.2/spec.html#b-nb-literal-next(n)
1873. https://yaml.org/spec/1.2/spec.html#b-chomped-last(t)
1874. https://yaml.org/spec/1.2/spec.html#l-chomped-empty(n,t)
1875. https://yaml.org/spec/1.2/spec.html#l-nb-literal-text(n)
1876. https://yaml.org/spec/1.2/spec.html#b-nb-literal-next(n)
1877. https://yaml.org/spec/1.2/spec.html#b-chomped-last(t)
1878. https://yaml.org/spec/1.2/spec.html#l-chomped-empty(n,t)
1879. https://yaml.org/spec/1.2/spec.html#style/block/literal
1880. https://yaml.org/spec/1.2/spec.html#line folding/block/
1881. https://yaml.org/spec/1.2/spec.html#c-folded
1882. https://yaml.org/spec/1.2/spec.html#c-b-block-header(m,t)
1883. https://yaml.org/spec/1.2/spec.html#l-folded-content(n,t)
1884. https://yaml.org/spec/1.2/spec.html#c-l+folded(n)
1885. https://yaml.org/spec/1.2/spec.html#line folding//
1886. https://yaml.org/spec/1.2/spec.html#space//
1887. https://yaml.org/spec/1.2/spec.html#space/white/
1888. https://yaml.org/spec/1.2/spec.html#s-indent(n)
1889. https://yaml.org/spec/1.2/spec.html#ns-char
1890. https://yaml.org/spec/1.2/spec.html#nb-char
1891. https://yaml.org/spec/1.2/spec.html#s-nb-folded-text(n)
1892. https://yaml.org/spec/1.2/spec.html#b-l-folded(n,c)
1893. https://yaml.org/spec/1.2/spec.html#s-nb-folded-text(n)
1894. https://yaml.org/spec/1.2/spec.html#s-nb-folded-text(n)
1895. https://yaml.org/spec/1.2/spec.html#l-nb-folded-lines(n)
1896. https://yaml.org/spec/1.2/spec.html#space/white/
1897. https://yaml.org/spec/1.2/spec.html#line folding//
1898. https://yaml.org/spec/1.2/spec.html#s-indent(n)
1899. https://yaml.org/spec/1.2/spec.html#s-white
1900. https://yaml.org/spec/1.2/spec.html#nb-char
1901. https://yaml.org/spec/1.2/spec.html#b-as-line-feed
1902. https://yaml.org/spec/1.2/spec.html#l-empty(n,c)
1903. https://yaml.org/spec/1.2/spec.html#s-nb-spaced-text(n)
1904. https://yaml.org/spec/1.2/spec.html#b-l-spaced(n)
1905. https://yaml.org/spec/1.2/spec.html#s-nb-spaced-text(n)
1906. https://yaml.org/spec/1.2/spec.html#s-nb-spaced-text(n)
1907. https://yaml.org/spec/1.2/spec.html#l-nb-spaced-lines(n)
1908. https://yaml.org/spec/1.2/spec.html#line break//
1909. https://yaml.org/spec/1.2/spec.html#empty line//
1910. https://yaml.org/spec/1.2/spec.html#line folding//
1911. https://yaml.org/spec/1.2/spec.html#l-empty(n,c)
1912. https://yaml.org/spec/1.2/spec.html#l-nb-folded-lines(n)
1913. https://yaml.org/spec/1.2/spec.html#l-nb-spaced-lines(n)
1914. https://yaml.org/spec/1.2/spec.html#l-nb-same-lines(n)
1915. https://yaml.org/spec/1.2/spec.html#b-as-line-feed
1916. https://yaml.org/spec/1.2/spec.html#l-nb-same-lines(n)
1917. https://yaml.org/spec/1.2/spec.html#b-as-line-feed
1918. https://yaml.org/spec/1.2/spec.html#l-empty(n,c)
1919. https://yaml.org/spec/1.2/spec.html#line break//
1920. https://yaml.org/spec/1.2/spec.html#empty line//
1921. https://yaml.org/spec/1.2/spec.html#chomping//
1922. https://yaml.org/spec/1.2/spec.html#line folding//
1923. https://yaml.org/spec/1.2/spec.html#l-nb-diff-lines(n)
1924. https://yaml.org/spec/1.2/spec.html#b-chomped-last(t)
1925. https://yaml.org/spec/1.2/spec.html#l-chomped-empty(n,t)
1926. https://yaml.org/spec/1.2/spec.html#b-chomped-last(t)
1927. https://yaml.org/spec/1.2/spec.html#l-chomped-empty(n,t)
1928. https://yaml.org/spec/1.2/spec.html#indicator//
1929. https://yaml.org/spec/1.2/spec.html#style/flow/plain
1930. https://yaml.org/spec/1.2/spec.html#key: value pair//
1931. https://yaml.org/spec/1.2/spec.html#- block sequence entry//
1932. https://yaml.org/spec/1.2/spec.html#node//
1933. https://yaml.org/spec/1.2/spec.html#space/separation/
1934. https://yaml.org/spec/1.2/spec.html#node//
1935. https://yaml.org/spec/1.2/spec.html#space/white/
1936. https://yaml.org/spec/1.2/spec.html#style/flow/plain
1937. https://yaml.org/spec/1.2/spec.html#s-indent(n)
1938. https://yaml.org/spec/1.2/spec.html#c-l-block-seq-entry(n)
1939. https://yaml.org/spec/1.2/spec.html#c-sequence-entry
1940. https://yaml.org/spec/1.2/spec.html#ns-char
1941. https://yaml.org/spec/1.2/spec.html#s-l+block-indented(n,c)
1942. https://yaml.org/spec/1.2/spec.html#c-l-block-seq-entry(n)
1943. https://yaml.org/spec/1.2/spec.html#s-indent(n)
1944. https://yaml.org/spec/1.2/spec.html#node//
1945. https://yaml.org/spec/1.2/spec.html#node/completely empty/
1946. https://yaml.org/spec/1.2/spec.html#style/block/
1947. https://yaml.org/spec/1.2/spec.html#style/block/collection
1948. https://yaml.org/spec/1.2/spec.html#space//
1949. https://yaml.org/spec/1.2/spec.html#space/indentation/
1950. https://yaml.org/spec/1.2/spec.html#style/block/collection
1951. https://yaml.org/spec/1.2/spec.html#node/property/
1952. https://yaml.org/spec/1.2/spec.html#style/block/collection
1953. https://yaml.org/spec/1.2/spec.html#s-indent(n)
1954. https://yaml.org/spec/1.2/spec.html#ns-l-compact-sequence(n)
1955. https://yaml.org/spec/1.2/spec.html#ns-l-compact-mapping(n)
1956. https://yaml.org/spec/1.2/spec.html#s-l+block-node(n,c)
1957. https://yaml.org/spec/1.2/spec.html#e-node
1958. https://yaml.org/spec/1.2/spec.html#s-l-comments
1959. https://yaml.org/spec/1.2/spec.html#c-l-block-seq-entry(n)
1960. https://yaml.org/spec/1.2/spec.html#s-indent(n)
1961. https://yaml.org/spec/1.2/spec.html#c-l-block-seq-entry(n)
1962. https://yaml.org/spec/1.2/spec.html#s-l+block-node(n,c)
1963. https://yaml.org/spec/1.2/spec.html#ns-l-compact-sequence(n)
1964. https://yaml.org/spec/1.2/spec.html#ns-l-compact-mapping(n)
1965. https://yaml.org/spec/1.2/spec.html#present//
1966. https://yaml.org/spec/1.2/spec.html#key: value pair//
1967. https://yaml.org/spec/1.2/spec.html#s-indent(n)
1968. https://yaml.org/spec/1.2/spec.html#ns-l-block-map-entry(n)
1969. https://yaml.org/spec/1.2/spec.html#ns-l-block-map-entry(n)
1970. https://yaml.org/spec/1.2/spec.html#s-indent(n)
1971. https://yaml.org/spec/1.2/spec.html#? mapping key//
1972. https://yaml.org/spec/1.2/spec.html#: mapping value//
1973. https://yaml.org/spec/1.2/spec.html#style/compact block collection/
1974. https://yaml.org/spec/1.2/spec.html#style/block/sequence
1975. https://yaml.org/spec/1.2/spec.html#c-l-block-map-explicit-entry(n)
1976. https://yaml.org/spec/1.2/spec.html#ns-l-block-map-implicit-entry(n)
1977. https://yaml.org/spec/1.2/spec.html#c-l-block-map-explicit-key(n)
1978. https://yaml.org/spec/1.2/spec.html#l-block-map-explicit-value(n)
1979. https://yaml.org/spec/1.2/spec.html#e-node
1980. https://yaml.org/spec/1.2/spec.html#c-mapping-key
1981. https://yaml.org/spec/1.2/spec.html#s-l+block-indented(n,c)
1982. https://yaml.org/spec/1.2/spec.html#s-indent(n)
1983. https://yaml.org/spec/1.2/spec.html#c-mapping-value
1984. https://yaml.org/spec/1.2/spec.html#s-l+block-indented(n,c)
1985. https://yaml.org/spec/1.2/spec.html#c-l-block-map-explicit-key(n)
1986. https://yaml.org/spec/1.2/spec.html#l-block-map-explicit-value(n)
1987. https://yaml.org/spec/1.2/spec.html#e-node
1988. https://yaml.org/spec/1.2/spec.html#parse//
1989. https://yaml.org/spec/1.2/spec.html#key/implicit/
1990. https://yaml.org/spec/1.2/spec.html#style/single key:value pair mapping/
1991. https://yaml.org/spec/1.2/spec.html#style/flow/mapping
1992. https://yaml.org/spec/1.2/spec.html#key//
1993. https://yaml.org/spec/1.2/spec.html#ns-s-block-map-implicit-key
1994. https://yaml.org/spec/1.2/spec.html#e-node
1995. https://yaml.org/spec/1.2/spec.html#c-l-block-map-implicit-value(n)
1996. https://yaml.org/spec/1.2/spec.html#c-s-implicit-json-key(c)
1997. https://yaml.org/spec/1.2/spec.html#ns-s-implicit-yaml-key(c)
1998. https://yaml.org/spec/1.2/spec.html#value//
1999. https://yaml.org/spec/1.2/spec.html#key/implicit/
2000. https://yaml.org/spec/1.2/spec.html#value//
2001. https://yaml.org/spec/1.2/spec.html#JSON compatibility//
2002. https://yaml.org/spec/1.2/spec.html#style/flow/mapping
2003. https://yaml.org/spec/1.2/spec.html#value//
2004. https://yaml.org/spec/1.2/spec.html#key/implicit/
2005. https://yaml.org/spec/1.2/spec.html#value//
2006. https://yaml.org/spec/1.2/spec.html#: mapping value//
2007. https://yaml.org/spec/1.2/spec.html#style/flow/plain
2008. https://yaml.org/spec/1.2/spec.html#c-mapping-value
2009. https://yaml.org/spec/1.2/spec.html#s-l+block-node(n,c)
2010. https://yaml.org/spec/1.2/spec.html#e-node
2011. https://yaml.org/spec/1.2/spec.html#s-l-comments
2012. https://yaml.org/spec/1.2/spec.html#ns-s-block-map-implicit-key
2013. https://yaml.org/spec/1.2/spec.html#c-l-block-map-implicit-value(n)
2014. https://yaml.org/spec/1.2/spec.html#style/compact block collection/
2015. https://yaml.org/spec/1.2/spec.html#style/block/sequence
2016. https://yaml.org/spec/1.2/spec.html#node/property/
2017. https://yaml.org/spec/1.2/spec.html#ns-l-block-map-entry(n)
2018. https://yaml.org/spec/1.2/spec.html#s-indent(n)
2019. https://yaml.org/spec/1.2/spec.html#ns-l-block-map-entry(n)
2020. https://yaml.org/spec/1.2/spec.html#ns-l-compact-mapping(n)
2021. https://yaml.org/spec/1.2/spec.html#style/flow/
2022. https://yaml.org/spec/1.2/spec.html#style/block/collection
2023. https://yaml.org/spec/1.2/spec.html#style/flow/
2024. https://yaml.org/spec/1.2/spec.html#space/indentation/
2025. https://yaml.org/spec/1.2/spec.html#space//
2026. https://yaml.org/spec/1.2/spec.html#style/block/collection
2027. https://yaml.org/spec/1.2/spec.html#style/flow/
2028. https://yaml.org/spec/1.2/spec.html#parse//
2029. https://yaml.org/spec/1.2/spec.html#style/flow/plain
2030. https://yaml.org/spec/1.2/spec.html#key/implicit/
2031. https://yaml.org/spec/1.2/spec.html#style/block/mapping
2032. https://yaml.org/spec/1.2/spec.html#s-l+block-in-block(n,c)
2033. https://yaml.org/spec/1.2/spec.html#s-l+flow-in-block(n)
2034. https://yaml.org/spec/1.2/spec.html#s-separate(n,c)
2035. https://yaml.org/spec/1.2/spec.html#ns-flow-node(n,c)
2036. https://yaml.org/spec/1.2/spec.html#s-l-comments
2037. https://yaml.org/spec/1.2/spec.html#s-l+flow-in-block(n)
2038. https://yaml.org/spec/1.2/spec.html#s-l+block-in-block(n,c)
2039. https://yaml.org/spec/1.2/spec.html#node/property/
2040. https://yaml.org/spec/1.2/spec.html#space/indentation/
2041. https://yaml.org/spec/1.2/spec.html#space//
2042. https://yaml.org/spec/1.2/spec.html#style/block/collection
2043. https://yaml.org/spec/1.2/spec.html#space/indentation/
2044. https://yaml.org/spec/1.2/spec.html#style/block/collection
2045. https://yaml.org/spec/1.2/spec.html#s-l+block-scalar(n,c)
2046. https://yaml.org/spec/1.2/spec.html#s-l+block-collection(n,c)
2047. https://yaml.org/spec/1.2/spec.html#s-separate(n,c)
2048. https://yaml.org/spec/1.2/spec.html#c-ns-properties(n,c)
2049. https://yaml.org/spec/1.2/spec.html#s-separate(n,c)
2050. https://yaml.org/spec/1.2/spec.html#c-l+literal(n)
2051. https://yaml.org/spec/1.2/spec.html#c-l+folded(n)
2052. https://yaml.org/spec/1.2/spec.html#c-l+literal(n)
2053. https://yaml.org/spec/1.2/spec.html#c-l+folded(n)
2054. https://yaml.org/spec/1.2/spec.html#- block sequence entry//
2055. https://yaml.org/spec/1.2/spec.html#space/indentation/
2056. https://yaml.org/spec/1.2/spec.html#style/block/sequence
2057. https://yaml.org/spec/1.2/spec.html#space/indentation/
2058. https://yaml.org/spec/1.2/spec.html#space//
2059. https://yaml.org/spec/1.2/spec.html#style/block/sequence
2060. https://yaml.org/spec/1.2/spec.html#context/block-out/
2061. https://yaml.org/spec/1.2/spec.html#context/block-in/
2062. https://yaml.org/spec/1.2/spec.html#s-separate(n,c)
2063. https://yaml.org/spec/1.2/spec.html#c-ns-properties(n,c)
2064. https://yaml.org/spec/1.2/spec.html#s-l-comments
2065. https://yaml.org/spec/1.2/spec.html#l+block-sequence(n)
2066. https://yaml.org/spec/1.2/spec.html#seq-spaces(n,c)
2067. https://yaml.org/spec/1.2/spec.html#l+block-sequence(n)
2068. https://yaml.org/spec/1.2/spec.html#l+block-mapping(n)
2069. https://yaml.org/spec/1.2/spec.html#l+block-sequence(n)
2070. https://yaml.org/spec/1.2/spec.html#l+block-mapping(n)
2071. https://yaml.org/spec/1.2/spec.html#s-l+block-collection(n,c)
2072. https://yaml.org/spec/1.2/spec.html#stream//
2073. https://yaml.org/spec/1.2/spec.html#character encoding//
2074. https://yaml.org/spec/1.2/spec.html#comment//
2075. https://yaml.org/spec/1.2/spec.html#document//
2076. https://yaml.org/spec/1.2/spec.html#character encoding//
2077. https://yaml.org/spec/1.2/spec.html#character encoding//
2078. https://yaml.org/spec/1.2/spec.html#byte order mark//
2079. https://yaml.org/spec/1.2/spec.html#document//
2080. https://yaml.org/spec/1.2/spec.html#document//
2081. https://yaml.org/spec/1.2/spec.html#c-byte-order-mark
2082. https://yaml.org/spec/1.2/spec.html#l-comment
2083. https://yaml.org/spec/1.2/spec.html#l-document-prefix
2084. https://yaml.org/spec/1.2/spec.html#directive//
2085. https://yaml.org/spec/1.2/spec.html#% directive//
2086. https://yaml.org/spec/1.2/spec.html#style/flow/plain
2087. https://yaml.org/spec/1.2/spec.html#directive//
2088. https://yaml.org/spec/1.2/spec.html#content//
2089. https://yaml.org/spec/1.2/spec.html#% directive//
2090. https://yaml.org/spec/1.2/spec.html#directive//
2091. https://yaml.org/spec/1.2/spec.html#document//
2092. https://yaml.org/spec/1.2/spec.html#document//
2093. https://yaml.org/spec/1.2/spec.html#% directive//
2094. https://yaml.org/spec/1.2/spec.html#directive//
2095. https://yaml.org/spec/1.2/spec.html#directive//
2096. https://yaml.org/spec/1.2/spec.html#% directive//
2097. https://yaml.org/spec/1.2/spec.html#document//
2098. https://yaml.org/spec/1.2/spec.html#parse//
2099. https://yaml.org/spec/1.2/spec.html#directive//
2100. https://yaml.org/spec/1.2/spec.html#document//
2101. https://yaml.org/spec/1.2/spec.html#content//
2102. https://yaml.org/spec/1.2/spec.html#c-document-end
2103. https://yaml.org/spec/1.2/spec.html#s-l-comments
2104. https://yaml.org/spec/1.2/spec.html#c-directives-end
2105. https://yaml.org/spec/1.2/spec.html#c-document-end
2106. https://yaml.org/spec/1.2/spec.html#b-char
2107. https://yaml.org/spec/1.2/spec.html#s-white
2108. https://yaml.org/spec/1.2/spec.html#c-directives-end
2109. https://yaml.org/spec/1.2/spec.html#c-document-end
2110. https://yaml.org/spec/1.2/spec.html#l-document-suffix
2111. https://yaml.org/spec/1.2/spec.html#directive//
2112. https://yaml.org/spec/1.2/spec.html#marker//
2113. https://yaml.org/spec/1.2/spec.html#content//
2114. https://yaml.org/spec/1.2/spec.html#% directive//
2115. https://yaml.org/spec/1.2/spec.html#node//
2116. https://yaml.org/spec/1.2/spec.html#space/indentation/
2117. https://yaml.org/spec/1.2/spec.html#space/indentation/
2118. https://yaml.org/spec/1.2/spec.html#space//
2119. https://yaml.org/spec/1.2/spec.html#node//
2120. https://yaml.org/spec/1.2/spec.html#space/indentation/
2121. https://yaml.org/spec/1.2/spec.html#node//
2122. https://yaml.org/spec/1.2/spec.html#node//
2123. https://yaml.org/spec/1.2/spec.html#space/indentation/
2124. https://yaml.org/spec/1.2/spec.html#space//
2125. https://yaml.org/spec/1.2/spec.html#s-l+block-node(n,c)
2126. https://yaml.org/spec/1.2/spec.html#c-forbidden
2127. https://yaml.org/spec/1.2/spec.html#l-bare-document
2128. https://yaml.org/spec/1.2/spec.html#marker/directives end/
2129. https://yaml.org/spec/1.2/spec.html#directive//
2130. https://yaml.org/spec/1.2/spec.html#document//
2131. https://yaml.org/spec/1.2/spec.html#marker//
2132. https://yaml.org/spec/1.2/spec.html#document//
2133. https://yaml.org/spec/1.2/spec.html#node/completely empty/
2134. https://yaml.org/spec/1.2/spec.html#c-directives-end
2135. https://yaml.org/spec/1.2/spec.html#l-bare-document
2136. https://yaml.org/spec/1.2/spec.html#e-node
2137. https://yaml.org/spec/1.2/spec.html#s-l-comments
2138. https://yaml.org/spec/1.2/spec.html#l-explicit-document
2139. https://yaml.org/spec/1.2/spec.html#directive//
2140. https://yaml.org/spec/1.2/spec.html#marker/directives end/
2141. https://yaml.org/spec/1.2/spec.html#l-directive
2142. https://yaml.org/spec/1.2/spec.html#l-explicit-document
2143. https://yaml.org/spec/1.2/spec.html#l-explicit-document
2144. https://yaml.org/spec/1.2/spec.html#document//
2145. https://yaml.org/spec/1.2/spec.html#document//
2146. https://yaml.org/spec/1.2/spec.html#marker//
2147. https://yaml.org/spec/1.2/spec.html#document//
2148. https://yaml.org/spec/1.2/spec.html#marker/document end/
2149. https://yaml.org/spec/1.2/spec.html#document//
2150. https://yaml.org/spec/1.2/spec.html#marker/directives end/
2151. https://yaml.org/spec/1.2/spec.html#l-directive-document
2152. https://yaml.org/spec/1.2/spec.html#l-explicit-document
2153. https://yaml.org/spec/1.2/spec.html#l-bare-document
2154. https://yaml.org/spec/1.2/spec.html#l-document-prefix
2155. https://yaml.org/spec/1.2/spec.html#l-any-document
2156. https://yaml.org/spec/1.2/spec.html#l-document-suffix
2157. https://yaml.org/spec/1.2/spec.html#l-document-prefix
2158. https://yaml.org/spec/1.2/spec.html#l-any-document
2159. https://yaml.org/spec/1.2/spec.html#l-document-prefix
2160. https://yaml.org/spec/1.2/spec.html#l-explicit-document
2161. https://yaml.org/spec/1.2/spec.html#l-any-document
2162. https://yaml.org/spec/1.2/spec.html#l-document-suffix
2163. https://yaml.org/spec/1.2/spec.html#l-explicit-document
2164. https://yaml.org/spec/1.2/spec.html#document//
2165. https://yaml.org/spec/1.2/spec.html#application//
2166. https://yaml.org/spec/1.2/spec.html#document//
2167. https://yaml.org/spec/1.2/spec.html#character encoding//
2168. https://yaml.org/spec/1.2/spec.html#document//
2169. https://yaml.org/spec/1.2/spec.html#document//
2170. https://yaml.org/spec/1.2/spec.html#marker/document end/
2171. https://yaml.org/spec/1.2/spec.html#marker/document end/
2172. https://yaml.org/spec/1.2/spec.html#document//
2173. https://yaml.org/spec/1.2/spec.html#document//
2174. https://yaml.org/spec/1.2/spec.html#document//
2175. https://yaml.org/spec/1.2/spec.html#comment//
2176. https://yaml.org/spec/1.2/spec.html#marker/document end/
2177. https://yaml.org/spec/1.2/spec.html#document//
2178. https://yaml.org/spec/1.2/spec.html#tag//
2179. https://yaml.org/spec/1.2/spec.html#tag/resolution/
2180. https://yaml.org/spec/1.2/spec.html#tag/non-specific/
2181. https://yaml.org/spec/1.2/spec.html#document//
2182. https://yaml.org/spec/1.2/spec.html#schema//
2183. https://yaml.org/spec/1.2/spec.html#processor//
2184. https://yaml.org/spec/1.2/spec.html#schema//
2185. https://yaml.org/spec/1.2/spec.html#mapping//
2186. https://yaml.org/spec/1.2/spec.html#represent//
2187. https://yaml.org/spec/1.2/spec.html#key//
2188. https://yaml.org/spec/1.2/spec.html#value//
2189. https://yaml.org/spec/1.2/spec.html#key//
2190. https://yaml.org/spec/1.2/spec.html#scalar//
2191. https://yaml.org/spec/1.2/spec.html#construct//
2192. https://yaml.org/spec/1.2/spec.html#native data structure//
2193. https://yaml.org/spec/1.2/spec.html#sequence//
2194. https://yaml.org/spec/1.2/spec.html#represent//
2195. https://yaml.org/spec/1.2/spec.html#construct//
2196. https://yaml.org/spec/1.2/spec.html#native data structure//
2197. https://yaml.org/spec/1.2/spec.html#scalar//
2198. https://yaml.org/spec/1.2/spec.html#represent//
2199. https://yaml.org/spec/1.2/spec.html#construct//
2200. https://yaml.org/spec/1.2/spec.html#native data structure//
2201. https://yaml.org/spec/1.2/spec.html#node//
2202. https://yaml.org/spec/1.2/spec.html#! tag indicator/! non-specific tag/
2203. https://yaml.org/spec/1.2/spec.html#tag/resolution/
2204. https://yaml.org/spec/1.2/spec.html#tag/resolution/convention
2205. https://yaml.org/spec/1.2/spec.html#kind//
2206. https://yaml.org/spec/1.2/spec.html#node//
2207. https://yaml.org/spec/1.2/spec.html#? non-specific tag//
2208. https://yaml.org/spec/1.2/spec.html#tag/resolution/
2209. https://yaml.org/spec/1.2/spec.html#application//
2210. https://yaml.org/spec/1.2/spec.html#representation/partial/
2211. https://yaml.org/spec/1.2/spec.html#parse//
2212. https://yaml.org/spec/1.2/spec.html#processor//
2213. https://yaml.org/spec/1.2/spec.html#schema//
2214. https://yaml.org/spec/1.2/spec.html#schema//
2215. https://yaml.org/spec/1.2/spec.html#schema//
2216. https://yaml.org/spec/1.2/spec.html#tag//
2217. https://yaml.org/spec/1.2/spec.html#schema/failsafe/
2218. https://yaml.org/spec/1.2/spec.html#scalar//
2219. https://yaml.org/spec/1.2/spec.html#represent//
2220. https://yaml.org/spec/1.2/spec.html#construct//
2221. https://yaml.org/spec/1.2/spec.html#native data structure//
2222. https://yaml.org/spec/1.2/spec.html#mapping//
2223. https://yaml.org/spec/1.2/spec.html#key//
2224. https://yaml.org/spec/1.2/spec.html#value//
2225. https://yaml.org/spec/1.2/spec.html#key//
2226. https://yaml.org/spec/1.2/spec.html#mapping//
2227. https://yaml.org/spec/1.2/spec.html#scalar//
2228. https://yaml.org/spec/1.2/spec.html#represent//
2229. https://yaml.org/spec/1.2/spec.html#native data structure//
2230. https://yaml.org/spec/1.2/spec.html#construct//
2231. https://yaml.org/spec/1.2/spec.html#scalar//
2232. https://yaml.org/spec/1.2/spec.html#represent//
2233. https://yaml.org/spec/1.2/spec.html#construct//
2234. https://yaml.org/spec/1.2/spec.html#native data structure//
2235. https://yaml.org/spec/1.2/spec.html#processor//
2236. https://yaml.org/spec/1.2/spec.html#native data structure//
2237. https://yaml.org/spec/1.2/spec.html#processor//
2238. https://yaml.org/spec/1.2/spec.html#scalar//
2239. https://yaml.org/spec/1.2/spec.html#represent//
2240. https://yaml.org/spec/1.2/spec.html#processor//
2241. https://yaml.org/spec/1.2/spec.html#native data structure//
2242. https://yaml.org/spec/1.2/spec.html#key//
2243. https://yaml.org/spec/1.2/spec.html#schema/JSON/
2244. https://yaml.org/spec/1.2/spec.html#tag/resolution/
2245. https://yaml.org/spec/1.2/spec.html#schema/failsafe/
2246. https://yaml.org/spec/1.2/spec.html#tag/resolution/
2247. https://yaml.org/spec/1.2/spec.html#node//
2248. https://yaml.org/spec/1.2/spec.html#! tag indicator/! non-specific tag/
2249. https://yaml.org/spec/1.2/spec.html#tag/resolution/
2250. https://yaml.org/spec/1.2/spec.html#tag/resolution/convention
2251. https://yaml.org/spec/1.2/spec.html#kind//
2252. https://yaml.org/spec/1.2/spec.html#collection//
2253. https://yaml.org/spec/1.2/spec.html#? non-specific tag//
2254. https://yaml.org/spec/1.2/spec.html#tag/non-specific/
2255. https://yaml.org/spec/1.2/spec.html#collection//
2256. https://yaml.org/spec/1.2/spec.html#tag/resolution/
2257. https://yaml.org/spec/1.2/spec.html#kind//
2258. https://yaml.org/spec/1.2/spec.html#scalar//
2259. https://yaml.org/spec/1.2/spec.html#? non-specific tag//
2260. https://yaml.org/spec/1.2/spec.html#style/flow/plain
2261. https://yaml.org/spec/1.2/spec.html#scalar//
2262. https://yaml.org/spec/1.2/spec.html#processor//
2263. https://yaml.org/spec/1.2/spec.html#schema/JSON/
2264. https://yaml.org/spec/1.2/spec.html#present//
2265. https://yaml.org/spec/1.2/spec.html#schema//
2266. https://yaml.org/spec/1.2/spec.html#processor//
2267. https://yaml.org/spec/1.2/spec.html#schema//
2268. https://yaml.org/spec/1.2/spec.html#schema//
2269. https://yaml.org/spec/1.2/spec.html#tag//
2270. https://yaml.org/spec/1.2/spec.html#schema/JSON/
2271. https://yaml.org/spec/1.2/spec.html#schema/core/
2272. https://yaml.org/spec/1.2/spec.html#tag/resolution/
2273. https://yaml.org/spec/1.2/spec.html#schema/JSON/
2274. https://yaml.org/spec/1.2/spec.html#tag/resolution/
2275. https://yaml.org/spec/1.2/spec.html#node//
2276. https://yaml.org/spec/1.2/spec.html#! tag indicator/! non-specific tag/
2277. https://yaml.org/spec/1.2/spec.html#tag/resolution/
2278. https://yaml.org/spec/1.2/spec.html#tag/resolution/convention
2279. https://yaml.org/spec/1.2/spec.html#kind//
2280. https://yaml.org/spec/1.2/spec.html#collection//
2281. https://yaml.org/spec/1.2/spec.html#? non-specific tag//
2282. https://yaml.org/spec/1.2/spec.html#tag/non-specific/
2283. https://yaml.org/spec/1.2/spec.html#collection//
2284. https://yaml.org/spec/1.2/spec.html#tag/resolution/
2285. https://yaml.org/spec/1.2/spec.html#kind//
2286. https://yaml.org/spec/1.2/spec.html#scalar//
2287. https://yaml.org/spec/1.2/spec.html#? non-specific tag//
2288. https://yaml.org/spec/1.2/spec.html#style/flow/plain
2289. https://yaml.org/spec/1.2/spec.html#scalar//
2290. https://yaml.org/spec/1.2/spec.html#tag/resolution/
2291. https://yaml.org/spec/1.2/spec.html#schema//
2292. https://yaml.org/spec/1.2/spec.html#tag//
2293. https://yaml.org/spec/1.2/spec.html#processor//
2294. https://yaml.org/spec/1.2/spec.html#tag/local/
2295. https://yaml.org/spec/1.2/spec.html#native data structure//
2296. https://yaml.org/spec/1.2/spec.html#tag/local/
2297. https://yaml.org/spec/1.2/spec.html#application//
2298. https://yaml.org/spec/1.2/spec.html#application//
2299. https://yaml.org/spec/1.2/spec.html#schema//
2300. https://yaml.org/spec/1.2/spec.html#tag/global/
2301. https://yaml.org/spec/1.2/spec.html#represent//
2302. https://yaml.org/spec/1.2/spec.html#schema//
2303. https://yaml.org/spec/1.2/spec.html#tag/resolution/
2304. https://yaml.org/spec/1.2/spec.html#node//
2305. https://yaml.org/spec/1.2/spec.html#schema//
2306. https://yaml.org/spec/1.2/spec.html#tag/non-specific/
2307. https://yaml.org/spec/1.2/spec.html#node//
2308. https://yaml.org/spec/1.2/spec.html#schema//
2309. https://yaml.org/spec/1.2/spec.html#schema/core/
2310. https://yaml.org/spec/1.2/spec.html#schema//
2311. https://yaml.org/type/
2312. https://yaml.org/spec/1.2/spec.html#tag/global/
2313. https://yaml.org/spec/1.2/spec.html#document//
2314. https://yaml.org/spec/1.2/spec.html#application//
2315. https://yaml.org/spec/1.2/spec.html#application//
2316. http://lists.sourceforge.net/lists/listinfo/yaml-core
2317. https://yaml.org/spec/1.2/spec.html#id2761292
2318. https://yaml.org/spec/1.2/spec.html#id2772075
2319. https://yaml.org/spec/1.2/spec.html#id2784064
2320. https://yaml.org/spec/1.2/spec.html#id2764295
2321. https://yaml.org/spec/1.2/spec.html#id2782457
2322. https://yaml.org/spec/1.2/spec.html#id2783273
2323. https://yaml.org/spec/1.2/spec.html#id2784064
2324. https://yaml.org/spec/1.2/spec.html#id2768011
2325. https://yaml.org/spec/1.2/spec.html#id2784064
2326. https://yaml.org/spec/1.2/spec.html#id2803036
2327. https://yaml.org/spec/1.2/spec.html#id2804356
2328. https://yaml.org/spec/1.2/spec.html#id2805071
2329. https://yaml.org/spec/1.2/spec.html#id2782457
2330. https://yaml.org/spec/1.2/spec.html#id2782457
2331. https://yaml.org/spec/1.2/spec.html#id2782457
2332. https://yaml.org/spec/1.2/spec.html#id2784064
2333. https://yaml.org/spec/1.2/spec.html#id2772075
2334. https://yaml.org/spec/1.2/spec.html#id2787109
2335. https://yaml.org/spec/1.2/spec.html#id2759963
2336. https://yaml.org/spec/1.2/spec.html#id2772075
2337. https://yaml.org/spec/1.2/spec.html#id2780069
2338. https://yaml.org/spec/1.2/spec.html#id2788859
2339. https://yaml.org/spec/1.2/spec.html#id2793979
2340. https://yaml.org/spec/1.2/spec.html#id2772075
2341. https://yaml.org/spec/1.2/spec.html#id2781147
2342. https://yaml.org/spec/1.2/spec.html#id2800401
2343. https://yaml.org/spec/1.2/spec.html#id2800967
2344. https://yaml.org/spec/1.2/spec.html#id2764295
2345. https://yaml.org/spec/1.2/spec.html#id2775468
2346. https://yaml.org/spec/1.2/spec.html#id2784064
2347. https://yaml.org/spec/1.2/spec.html#id2760395
2348. https://yaml.org/spec/1.2/spec.html#id2772075
2349. https://yaml.org/spec/1.2/spec.html#id2785586
2350. https://yaml.org/spec/1.2/spec.html#id2772075
2351. https://yaml.org/spec/1.2/spec.html#id2772075
2352. https://yaml.org/spec/1.2/spec.html#id2788097
2353. https://yaml.org/spec/1.2/spec.html#id2760395
2354. https://yaml.org/spec/1.2/spec.html#id2772075
2355. https://yaml.org/spec/1.2/spec.html#id2786196
2356. https://yaml.org/spec/1.2/spec.html#id2794534
2357. https://yaml.org/spec/1.2/spec.html#id2759963
2358. https://yaml.org/spec/1.2/spec.html#id2772075
2359. https://yaml.org/spec/1.2/spec.html#id2775468
2360. https://yaml.org/spec/1.2/spec.html#id2784064
2361. https://yaml.org/spec/1.2/spec.html#id2785586
2362. https://yaml.org/spec/1.2/spec.html#id2788859
2363. https://yaml.org/spec/1.2/spec.html#id2790088
2364. https://yaml.org/spec/1.2/spec.html#id2790320
2365. https://yaml.org/spec/1.2/spec.html#id2790832
2366. https://yaml.org/spec/1.2/spec.html#Introduction
2367. https://yaml.org/spec/1.2/spec.html#id2759963
2368. https://yaml.org/spec/1.2/spec.html#id2760395
2369. https://yaml.org/spec/1.2/spec.html#id2769866
2370. https://yaml.org/spec/1.2/spec.html#id2772075
2371. https://yaml.org/spec/1.2/spec.html#id2777534
2372. https://yaml.org/spec/1.2/spec.html#id2788859
2373. https://yaml.org/spec/1.2/spec.html#id2797293
2374. https://yaml.org/spec/1.2/spec.html#id2797382
2375. https://yaml.org/spec/1.2/spec.html#id2799181
2376. https://yaml.org/spec/1.2/spec.html#id2794534
2377. https://yaml.org/spec/1.2/spec.html#Introduction
2378. https://yaml.org/spec/1.2/spec.html#id2759963
2379. https://yaml.org/spec/1.2/spec.html#id2760395
2380. https://yaml.org/spec/1.2/spec.html#id2772075
2381. https://yaml.org/spec/1.2/spec.html#id2777534
2382. https://yaml.org/spec/1.2/spec.html#id2788859
2383. https://yaml.org/spec/1.2/spec.html#id2790832
2384. https://yaml.org/spec/1.2/spec.html#id2798057
2385. https://yaml.org/spec/1.2/spec.html#id2784064
2386. https://yaml.org/spec/1.2/spec.html#id2760844
2387. https://yaml.org/spec/1.2/spec.html#id2772075
2388. https://yaml.org/spec/1.2/spec.html#id2796251
2389. https://yaml.org/spec/1.2/spec.html#id2760395
2390. https://yaml.org/spec/1.2/spec.html#id2772075
2391. https://yaml.org/spec/1.2/spec.html#id2777534
2392. https://yaml.org/spec/1.2/spec.html#id2788859
2393. https://yaml.org/spec/1.2/spec.html#id2790832
2394. https://yaml.org/spec/1.2/spec.html#id2798057
2395. https://yaml.org/spec/1.2/spec.html#id2768011
2396. https://yaml.org/spec/1.2/spec.html#id2784064
2397. https://yaml.org/spec/1.2/spec.html#id2803036
2398. https://yaml.org/spec/1.2/spec.html#id2804356
2399. https://yaml.org/spec/1.2/spec.html#id2805071
2400. https://yaml.org/spec/1.2/spec.html#id2772075
2401. https://yaml.org/spec/1.2/spec.html#id2759963
2402. https://yaml.org/spec/1.2/spec.html#id2772075
2403. https://yaml.org/spec/1.2/spec.html#id2775468
2404. https://yaml.org/spec/1.2/spec.html#id2784064
2405. https://yaml.org/spec/1.2/spec.html#id2785586
2406. https://yaml.org/spec/1.2/spec.html#id2788859
2407. https://yaml.org/spec/1.2/spec.html#id2790320
2408. https://yaml.org/spec/1.2/spec.html#id2776092
2409. https://yaml.org/spec/1.2/spec.html#id2787109
2410. https://yaml.org/spec/1.2/spec.html#id2759963
2411. https://yaml.org/spec/1.2/spec.html#id2772075
2412. https://yaml.org/spec/1.2/spec.html#id2775468
2413. https://yaml.org/spec/1.2/spec.html#id2784064
2414. https://yaml.org/spec/1.2/spec.html#id2785586
2415. https://yaml.org/spec/1.2/spec.html#id2788859
2416. https://yaml.org/spec/1.2/spec.html#id2790320
2417. https://yaml.org/spec/1.2/spec.html#id2759963
2418. https://yaml.org/spec/1.2/spec.html#id2772075
2419. https://yaml.org/spec/1.2/spec.html#id2775468
2420. https://yaml.org/spec/1.2/spec.html#id2784064
2421. https://yaml.org/spec/1.2/spec.html#id2785586
2422. https://yaml.org/spec/1.2/spec.html#id2788859
2423. https://yaml.org/spec/1.2/spec.html#id2790832
2424. https://yaml.org/spec/1.2/spec.html#id2760844
2425. https://yaml.org/spec/1.2/spec.html#id2772075
2426. https://yaml.org/spec/1.2/spec.html#id2795688
2427. https://yaml.org/spec/1.2/spec.html#id2759963
2428. https://yaml.org/spec/1.2/spec.html#id2772075
2429. https://yaml.org/spec/1.2/spec.html#id2775468
2430. https://yaml.org/spec/1.2/spec.html#id2784064
2431. https://yaml.org/spec/1.2/spec.html#id2785586
2432. https://yaml.org/spec/1.2/spec.html#id2788859
2433. https://yaml.org/spec/1.2/spec.html#id2790832
2434. https://yaml.org/spec/1.2/spec.html#id2800168
2435. https://yaml.org/spec/1.2/spec.html#Introduction
2436. https://yaml.org/spec/1.2/spec.html#id2708710
2437. https://yaml.org/spec/1.2/spec.html#id2760395
2438. https://yaml.org/spec/1.2/spec.html#id2762313
2439. https://yaml.org/spec/1.2/spec.html#id2765410
2440. https://yaml.org/spec/1.2/spec.html#id2765878
2441. https://yaml.org/spec/1.2/spec.html#id2767381
2442. https://yaml.org/spec/1.2/spec.html#id2767852
2443. https://yaml.org/spec/1.2/spec.html#id2768011
2444. https://yaml.org/spec/1.2/spec.html#id2772075
2445. https://yaml.org/spec/1.2/spec.html#id2785586
2446. https://yaml.org/spec/1.2/spec.html#Flow
2447. https://yaml.org/spec/1.2/spec.html#id2786196
2448. https://yaml.org/spec/1.2/spec.html#id2792977
2449. https://yaml.org/spec/1.2/spec.html#id2760395
2450. https://yaml.org/spec/1.2/spec.html#id2765878
2451. https://yaml.org/spec/1.2/spec.html#id2767852
2452. https://yaml.org/spec/1.2/spec.html#id2767381
2453. https://yaml.org/spec/1.2/spec.html#id2767852
2454. https://yaml.org/spec/1.2/spec.html#id2760395
2455. https://yaml.org/spec/1.2/spec.html#id2762313
2456. https://yaml.org/spec/1.2/spec.html#id2765410
2457. https://yaml.org/spec/1.2/spec.html#id2765878
2458. https://yaml.org/spec/1.2/spec.html#id2767852
2459. https://yaml.org/spec/1.2/spec.html#id2768011
2460. https://yaml.org/spec/1.2/spec.html#id2772075
2461. https://yaml.org/spec/1.2/spec.html#id2783797
2462. https://yaml.org/spec/1.2/spec.html#Flow
2463. https://yaml.org/spec/1.2/spec.html#id2786196
2464. https://yaml.org/spec/1.2/spec.html#id2792977
2465. https://yaml.org/spec/1.2/spec.html#Introduction
2466. https://yaml.org/spec/1.2/spec.html#id2708710
2467. https://yaml.org/spec/1.2/spec.html#id2761292
2468. https://yaml.org/spec/1.2/spec.html#Processing
2469. https://yaml.org/spec/1.2/spec.html#id2762313
2470. https://yaml.org/spec/1.2/spec.html#id2763452
2471. https://yaml.org/spec/1.2/spec.html#id2764295
2472. https://yaml.org/spec/1.2/spec.html#id2765410
2473. https://yaml.org/spec/1.2/spec.html#id2765608
2474. https://yaml.org/spec/1.2/spec.html#id2768011
2475. https://yaml.org/spec/1.2/spec.html#id2769542
2476. https://yaml.org/spec/1.2/spec.html#id2783273
2477. https://yaml.org/spec/1.2/spec.html#id2784064
2478. https://yaml.org/spec/1.2/spec.html#id2801681
2479. https://yaml.org/spec/1.2/spec.html#id2803036
2480. https://yaml.org/spec/1.2/spec.html#id2805770
2481. https://yaml.org/spec/1.2/spec.html#id2780069
2482. https://yaml.org/spec/1.2/spec.html#id2793718
2483. https://yaml.org/spec/1.2/spec.html#id2794534
2484. https://yaml.org/spec/1.2/spec.html#id2771184
2485. https://yaml.org/spec/1.2/spec.html#id2800168
2486. https://yaml.org/spec/1.2/spec.html#id2771184
2487. https://yaml.org/spec/1.2/spec.html#id2800168
2488. https://yaml.org/spec/1.2/spec.html#id2801681
2489. https://yaml.org/spec/1.2/spec.html#id2775468
2490. https://yaml.org/spec/1.2/spec.html#id2769866
2491. https://yaml.org/spec/1.2/spec.html#id2779048
2492. https://yaml.org/spec/1.2/spec.html#id2794534
2493. https://yaml.org/spec/1.2/spec.html#id2795688
2494. https://yaml.org/spec/1.2/spec.html#id2796251
2495. https://yaml.org/spec/1.2/spec.html#id2769866
2496. https://yaml.org/spec/1.2/spec.html#id2794534
2497. https://yaml.org/spec/1.2/spec.html#id2769866
2498. https://yaml.org/spec/1.2/spec.html#id2794534
2499. https://yaml.org/spec/1.2/spec.html#id2769866
2500. https://yaml.org/spec/1.2/spec.html#id2794534
2501. https://yaml.org/spec/1.2/spec.html#id2708710
2502. https://yaml.org/spec/1.2/spec.html#id2763754
2503. https://yaml.org/spec/1.2/spec.html#id2764044
2504. https://yaml.org/spec/1.2/spec.html#id2764652
2505. https://yaml.org/spec/1.2/spec.html#id2765878
2506. https://yaml.org/spec/1.2/spec.html#id2766446
2507. https://yaml.org/spec/1.2/spec.html#id2767100
2508. https://yaml.org/spec/1.2/spec.html#id2768011
2509. https://yaml.org/spec/1.2/spec.html#id2769212
2510. https://yaml.org/spec/1.2/spec.html#id2804356
2511. https://yaml.org/spec/1.2/spec.html#id2805071
2512. https://yaml.org/spec/1.2/spec.html#id2759963
2513. https://yaml.org/spec/1.2/spec.html#id2762107
2514. https://yaml.org/spec/1.2/spec.html#id2762313
2515. https://yaml.org/spec/1.2/spec.html#id2763035
2516. https://yaml.org/spec/1.2/spec.html#id2766150
2517. https://yaml.org/spec/1.2/spec.html#id2767100
2518. https://yaml.org/spec/1.2/spec.html#id2768011
2519. https://yaml.org/spec/1.2/spec.html#id2772075
2520. https://yaml.org/spec/1.2/spec.html#id2780069
2521. https://yaml.org/spec/1.2/spec.html#id2780810
2522. https://yaml.org/spec/1.2/spec.html#id2788859
2523. https://yaml.org/spec/1.2/spec.html#id2793718
2524. https://yaml.org/spec/1.2/spec.html#id2794534
2525. https://yaml.org/spec/1.2/spec.html#id2800168
2526. https://yaml.org/spec/1.2/spec.html#id2801681
2527. https://yaml.org/spec/1.2/spec.html#id2762107
2528. https://yaml.org/spec/1.2/spec.html#id2763035
2529. https://yaml.org/spec/1.2/spec.html#id2765608
2530. https://yaml.org/spec/1.2/spec.html#id2765878
2531. https://yaml.org/spec/1.2/spec.html#id2768011
2532. https://yaml.org/spec/1.2/spec.html#id2769212
2533. https://yaml.org/spec/1.2/spec.html#id2769542
2534. https://yaml.org/spec/1.2/spec.html#id2785586
2535. https://yaml.org/spec/1.2/spec.html#id2762107
2536. https://yaml.org/spec/1.2/spec.html#id2763035
2537. https://yaml.org/spec/1.2/spec.html#id2765410
2538. https://yaml.org/spec/1.2/spec.html#id2767381
2539. https://yaml.org/spec/1.2/spec.html#id2769212
2540. https://yaml.org/spec/1.2/spec.html#id2769542
2541. https://yaml.org/spec/1.2/spec.html#Flow
2542. https://yaml.org/spec/1.2/spec.html#id2802432
2543. https://yaml.org/spec/1.2/spec.html#id2802662
2544. https://yaml.org/spec/1.2/spec.html#id2802842
2545. https://yaml.org/spec/1.2/spec.html#id2803362
2546. https://yaml.org/spec/1.2/spec.html#id2803629
2547. https://yaml.org/spec/1.2/spec.html#id2803828
2548. https://yaml.org/spec/1.2/spec.html#id2760395
2549. https://yaml.org/spec/1.2/spec.html#id2762313
2550. https://yaml.org/spec/1.2/spec.html#id2764044
2551. https://yaml.org/spec/1.2/spec.html#id2764295
2552. https://yaml.org/spec/1.2/spec.html#id2764652
2553. https://yaml.org/spec/1.2/spec.html#id2767381
2554. https://yaml.org/spec/1.2/spec.html#id2768011
2555. https://yaml.org/spec/1.2/spec.html#id2769212
2556. https://yaml.org/spec/1.2/spec.html#id2771184
2557. https://yaml.org/spec/1.2/spec.html#id2774608
2558. https://yaml.org/spec/1.2/spec.html#id2776092
2559. https://yaml.org/spec/1.2/spec.html#id2777534
2560. https://yaml.org/spec/1.2/spec.html#id2778241
2561. https://yaml.org/spec/1.2/spec.html#id2778481
2562. https://yaml.org/spec/1.2/spec.html#id2778853
2563. https://yaml.org/spec/1.2/spec.html#id2779048
2564. https://yaml.org/spec/1.2/spec.html#id2780069
2565. https://yaml.org/spec/1.2/spec.html#id2781147
2566. https://yaml.org/spec/1.2/spec.html#id2782457
2567. https://yaml.org/spec/1.2/spec.html#id2783797
2568. https://yaml.org/spec/1.2/spec.html#id2784064
2569. https://yaml.org/spec/1.2/spec.html#id2785586
2570. https://yaml.org/spec/1.2/spec.html#id2786196
2571. https://yaml.org/spec/1.2/spec.html#id2786563
2572. https://yaml.org/spec/1.2/spec.html#id2786942
2573. https://yaml.org/spec/1.2/spec.html#id2787109
2574. https://yaml.org/spec/1.2/spec.html#id2788097
2575. https://yaml.org/spec/1.2/spec.html#id2788859
2576. https://yaml.org/spec/1.2/spec.html#id2793718
2577. https://yaml.org/spec/1.2/spec.html#id2793979
2578. https://yaml.org/spec/1.2/spec.html#id2794534
2579. https://yaml.org/spec/1.2/spec.html#id2795688
2580. https://yaml.org/spec/1.2/spec.html#id2800401
2581. https://yaml.org/spec/1.2/spec.html#id2800967
2582. https://yaml.org/spec/1.2/spec.html#id2769212
2583. https://yaml.org/spec/1.2/spec.html#id2769866
2584. https://yaml.org/spec/1.2/spec.html#id2788859
2585. https://yaml.org/spec/1.2/spec.html#id2769866
2586. https://yaml.org/spec/1.2/spec.html#id2799181
2587. https://yaml.org/spec/1.2/spec.html#id2769866
2588. https://yaml.org/spec/1.2/spec.html#id2790088
2589. https://yaml.org/spec/1.2/spec.html#id2769866
2590. https://yaml.org/spec/1.2/spec.html#id2799181
2591. https://yaml.org/spec/1.2/spec.html#id2769866
2592. https://yaml.org/spec/1.2/spec.html#id2790088
2593. https://yaml.org/spec/1.2/spec.html#id2769866
2594. https://yaml.org/spec/1.2/spec.html#id2790088
2595. https://yaml.org/spec/1.2/spec.html#id2769866
2596. https://yaml.org/spec/1.2/spec.html#id2790088
2597. https://yaml.org/spec/1.2/spec.html#id2760395
2598. https://yaml.org/spec/1.2/spec.html#id2762313
2599. https://yaml.org/spec/1.2/spec.html#id2763035
2600. https://yaml.org/spec/1.2/spec.html#id2766150
2601. https://yaml.org/spec/1.2/spec.html#id2767222
2602. https://yaml.org/spec/1.2/spec.html#id2772075
2603. https://yaml.org/spec/1.2/spec.html#id2781147
2604. https://yaml.org/spec/1.2/spec.html#id2800401
2605. https://yaml.org/spec/1.2/spec.html#id2800967
2606. https://yaml.org/spec/1.2/spec.html#id2801301
2607. https://yaml.org/spec/1.2/spec.html#id2801522
2608. https://yaml.org/spec/1.2/spec.html#id2767222
2609. https://yaml.org/spec/1.2/spec.html#id2781147
2610. https://yaml.org/spec/1.2/spec.html#id2764295
2611. https://yaml.org/spec/1.2/spec.html#id2767222
2612. https://yaml.org/spec/1.2/spec.html#id2772075
2613. https://yaml.org/spec/1.2/spec.html#id2781147
2614. https://yaml.org/spec/1.2/spec.html#id2782090
2615. https://yaml.org/spec/1.2/spec.html#id2784064
2616. https://yaml.org/spec/1.2/spec.html#id2767222
2617. https://yaml.org/spec/1.2/spec.html#id2781147
2618. https://yaml.org/spec/1.2/spec.html#id2781553
2619. https://yaml.org/spec/1.2/spec.html#id2708710
2620. https://yaml.org/spec/1.2/spec.html#id2760395
2621. https://yaml.org/spec/1.2/spec.html#id2766150
2622. https://yaml.org/spec/1.2/spec.html#id2767222
2623. https://yaml.org/spec/1.2/spec.html#id2767381
2624. https://yaml.org/spec/1.2/spec.html#id2768011
2625. https://yaml.org/spec/1.2/spec.html#id2769212
2626. https://yaml.org/spec/1.2/spec.html#id2771184
2627. https://yaml.org/spec/1.2/spec.html#id2774608
2628. https://yaml.org/spec/1.2/spec.html#id2781553
2629. https://yaml.org/spec/1.2/spec.html#id2783273
2630. https://yaml.org/spec/1.2/spec.html#id2786196
2631. https://yaml.org/spec/1.2/spec.html#id2800132
2632. https://yaml.org/spec/1.2/spec.html#id2800168
2633. https://yaml.org/spec/1.2/spec.html#id2800401
2634. https://yaml.org/spec/1.2/spec.html#id2801301
2635. https://yaml.org/spec/1.2/spec.html#id2801681
2636. https://yaml.org/spec/1.2/spec.html#id2802346
2637. https://yaml.org/spec/1.2/spec.html#id2805770
2638. https://yaml.org/spec/1.2/spec.html#id2800967
2639. https://yaml.org/spec/1.2/spec.html#id2801522
2640. https://yaml.org/spec/1.2/spec.html#id2801301
2641. https://yaml.org/spec/1.2/spec.html#id2800401
2642. https://yaml.org/spec/1.2/spec.html#id2762107
2643. https://yaml.org/spec/1.2/spec.html#id2762313
2644. https://yaml.org/spec/1.2/spec.html#id2708710
2645. https://yaml.org/spec/1.2/spec.html#id2760844
2646. https://yaml.org/spec/1.2/spec.html#id2778853
2647. https://yaml.org/spec/1.2/spec.html#id2779048
2648. https://yaml.org/spec/1.2/spec.html#id2793979
2649. https://yaml.org/spec/1.2/spec.html#id2794534
2650. https://yaml.org/spec/1.2/spec.html#id2795688
2651. https://yaml.org/spec/1.2/spec.html#id2796251
2652. https://yaml.org/spec/1.2/spec.html#id2759572
2653. https://yaml.org/spec/1.2/spec.html#id2762313
2654. https://yaml.org/spec/1.2/spec.html#id2763754
2655. https://yaml.org/spec/1.2/spec.html#id2764044
2656. https://yaml.org/spec/1.2/spec.html#id2764295
2657. https://yaml.org/spec/1.2/spec.html#id2764652
2658. https://yaml.org/spec/1.2/spec.html#id2766934
2659. https://yaml.org/spec/1.2/spec.html#id2767381
2660. https://yaml.org/spec/1.2/spec.html#id2769212
2661. https://yaml.org/spec/1.2/spec.html#id2708710
2662. https://yaml.org/spec/1.2/spec.html#id2760844
2663. https://yaml.org/spec/1.2/spec.html#id2770814
2664. https://yaml.org/spec/1.2/spec.html#id2771184
2665. https://yaml.org/spec/1.2/spec.html#id2775468
2666. https://yaml.org/spec/1.2/spec.html#id2776092
2667. https://yaml.org/spec/1.2/spec.html#id2787109
2668. https://yaml.org/spec/1.2/spec.html#id2788097
2669. https://yaml.org/spec/1.2/spec.html#id2775468
2670. https://yaml.org/spec/1.2/spec.html#id2787109
2671. https://yaml.org/spec/1.2/spec.html#id2764652
2672. https://yaml.org/spec/1.2/spec.html#Introduction
2673. https://yaml.org/spec/1.2/spec.html#id2708710
2674. https://yaml.org/spec/1.2/spec.html#id2759963
2675. https://yaml.org/spec/1.2/spec.html#id2766446
2676. https://yaml.org/spec/1.2/spec.html#id2769866
2677. https://yaml.org/spec/1.2/spec.html#id2772075
2678. https://yaml.org/spec/1.2/spec.html#id2779048
2679. https://yaml.org/spec/1.2/spec.html#id2788859
2680. https://yaml.org/spec/1.2/spec.html#id2790832
2681. https://yaml.org/spec/1.2/spec.html#id2792977
2682. https://yaml.org/spec/1.2/spec.html#Block
2683. https://yaml.org/spec/1.2/spec.html#id2793718
2684. https://yaml.org/spec/1.2/spec.html#id2797293
2685. https://yaml.org/spec/1.2/spec.html#id2793979
2686. https://yaml.org/spec/1.2/spec.html#id2772075
2687. https://yaml.org/spec/1.2/spec.html#id2763452
2688. https://yaml.org/spec/1.2/spec.html#id2767381
2689. https://yaml.org/spec/1.2/spec.html#id2769212
2690. https://yaml.org/spec/1.2/spec.html#id2770814
2691. https://yaml.org/spec/1.2/spec.html#id2771184
2692. https://yaml.org/spec/1.2/spec.html#id2774608
2693. https://yaml.org/spec/1.2/spec.html#id2776092
2694. https://yaml.org/spec/1.2/spec.html#id2780069
2695. https://yaml.org/spec/1.2/spec.html#id2781553
2696. https://yaml.org/spec/1.2/spec.html#id2790832
2697. https://yaml.org/spec/1.2/spec.html#id2798057
2698. https://yaml.org/spec/1.2/spec.html#id2790832
2699. https://yaml.org/spec/1.2/spec.html#id2792977
2700. https://yaml.org/spec/1.2/spec.html#id2759572
2701. https://yaml.org/spec/1.2/spec.html#id2760395
2702. https://yaml.org/spec/1.2/spec.html#id2762313
2703. https://yaml.org/spec/1.2/spec.html#id2763452
2704. https://yaml.org/spec/1.2/spec.html#id2763754
2705. https://yaml.org/spec/1.2/spec.html#id2764044
2706. https://yaml.org/spec/1.2/spec.html#id2764652
2707. https://yaml.org/spec/1.2/spec.html#id2765410
2708. https://yaml.org/spec/1.2/spec.html#id2765608
2709. https://yaml.org/spec/1.2/spec.html#id2768011
2710. https://yaml.org/spec/1.2/spec.html#id2772075
2711. https://yaml.org/spec/1.2/spec.html#id2790832
2712. https://yaml.org/spec/1.2/spec.html#id2798057
2713. https://yaml.org/spec/1.2/spec.html#id2802432
2714. https://yaml.org/spec/1.2/spec.html#id2803362
2715. https://yaml.org/spec/1.2/spec.html#id2804092
2716. https://yaml.org/spec/1.2/spec.html#id2780810
2717. https://yaml.org/spec/1.2/spec.html#id2787109
2718. https://yaml.org/spec/1.2/spec.html#id2788097
2719. https://yaml.org/spec/1.2/spec.html#id2788859
2720. https://yaml.org/spec/1.2/spec.html#id2790088
2721. https://yaml.org/spec/1.2/spec.html#id2790832
2722. https://yaml.org/spec/1.2/spec.html#id2798057
2723. https://yaml.org/spec/1.2/spec.html#id2799181
2724. https://yaml.org/spec/1.2/spec.html#id2762107
2725. https://yaml.org/spec/1.2/spec.html#id2762313
2726. https://yaml.org/spec/1.2/spec.html#id2763035
2727. https://yaml.org/spec/1.2/spec.html#id2763452
2728. https://yaml.org/spec/1.2/spec.html#id2765410
2729. https://yaml.org/spec/1.2/spec.html#id2765608
2730. https://yaml.org/spec/1.2/spec.html#Introduction
2731. https://yaml.org/spec/1.2/spec.html#id2759963
2732. https://yaml.org/spec/1.2/spec.html#id2760395
2733. https://yaml.org/spec/1.2/spec.html#id2764044
2734. https://yaml.org/spec/1.2/spec.html#id2765608
2735. https://yaml.org/spec/1.2/spec.html#id2766446
2736. https://yaml.org/spec/1.2/spec.html#id2788859
2737. https://yaml.org/spec/1.2/spec.html#id2790832
2738. https://yaml.org/spec/1.2/spec.html#id2797293
2739. https://yaml.org/spec/1.2/spec.html#id2798057
2740. https://yaml.org/spec/1.2/spec.html#id2762313
2741. https://yaml.org/spec/1.2/spec.html#id2763754
2742. https://yaml.org/spec/1.2/spec.html#id2764044
2743. https://yaml.org/spec/1.2/spec.html#id2764295
2744. https://yaml.org/spec/1.2/spec.html#id2764652
2745. https://yaml.org/spec/1.2/spec.html#id2766446
2746. https://yaml.org/spec/1.2/spec.html#id2768011
2747. https://yaml.org/spec/1.2/spec.html#id2784064
2748. https://yaml.org/spec/1.2/spec.html#id2803036
2749. https://yaml.org/spec/1.2/spec.html#id2804356
2750. https://yaml.org/spec/1.2/spec.html#id2805071
2751. https://yaml.org/spec/1.2/spec.html#id2708710
2752. https://yaml.org/spec/1.2/spec.html#id2760844
2753. https://yaml.org/spec/1.2/spec.html#id2769866
2754. https://yaml.org/spec/1.2/spec.html#id2770517
2755. https://yaml.org/spec/1.2/spec.html#id2774608
2756. https://yaml.org/spec/1.2/spec.html#id2775170
2757. https://yaml.org/spec/1.2/spec.html#id2778853
2758. https://yaml.org/spec/1.2/spec.html#id2779048
2759. https://yaml.org/spec/1.2/spec.html#id2780069
2760. https://yaml.org/spec/1.2/spec.html#id2787109
2761. https://yaml.org/spec/1.2/spec.html#id2793718
2762. https://yaml.org/spec/1.2/spec.html#id2794534
2763. https://yaml.org/spec/1.2/spec.html#id2795688
2764. https://yaml.org/spec/1.2/spec.html#id2796251
2765. https://yaml.org/spec/1.2/spec.html#id2774608
2766. https://yaml.org/spec/1.2/spec.html#id2781553
2767. https://yaml.org/spec/1.2/spec.html#id2774608
2768. https://yaml.org/spec/1.2/spec.html#id2795688
2769. https://yaml.org/spec/1.2/spec.html#id2708710
2770. https://yaml.org/spec/1.2/spec.html#id2760844
2771. https://yaml.org/spec/1.2/spec.html#id2779048
2772. https://yaml.org/spec/1.2/spec.html#Flow
2773. https://yaml.org/spec/1.2/spec.html#id2787109
2774. https://yaml.org/spec/1.2/spec.html#id2788097
2775. https://yaml.org/spec/1.2/spec.html#id2788859
2776. https://yaml.org/spec/1.2/spec.html#id2794534
2777. https://yaml.org/spec/1.2/spec.html#id2796251
2778. https://yaml.org/spec/1.2/spec.html#id2779048
2779. https://yaml.org/spec/1.2/spec.html#id2796251
2780. https://yaml.org/spec/1.2/spec.html#id2779048
2781. https://yaml.org/spec/1.2/spec.html#id2787109
2782. https://yaml.org/spec/1.2/spec.html#id2778481
2783. https://yaml.org/spec/1.2/spec.html#id2778853
2784. https://yaml.org/spec/1.2/spec.html#id2762107
2785. https://yaml.org/spec/1.2/spec.html#id2763035
2786. https://yaml.org/spec/1.2/spec.html#id2767381
2787. https://yaml.org/spec/1.2/spec.html#id2763035
2788. https://yaml.org/spec/1.2/spec.html#id2767381
2789. https://yaml.org/spec/1.2/spec.html#Introduction
2790. https://yaml.org/spec/1.2/spec.html#id2708710
2791. https://yaml.org/spec/1.2/spec.html#id2759572
2792. https://yaml.org/spec/1.2/spec.html#id2759963
2793. https://yaml.org/spec/1.2/spec.html#id2760395
2794. https://yaml.org/spec/1.2/spec.html#id2762313
2795. https://yaml.org/spec/1.2/spec.html#id2763754
2796. https://yaml.org/spec/1.2/spec.html#id2764044
2797. https://yaml.org/spec/1.2/spec.html#id2764295
2798. https://yaml.org/spec/1.2/spec.html#id2764652
2799. https://yaml.org/spec/1.2/spec.html#id2765608
2800. https://yaml.org/spec/1.2/spec.html#id2768011
2801. https://yaml.org/spec/1.2/spec.html#id2788859
2802. https://yaml.org/spec/1.2/spec.html#id2790320
2803. https://yaml.org/spec/1.2/spec.html#id2790832
2804. https://yaml.org/spec/1.2/spec.html#id2802432
2805. https://yaml.org/spec/1.2/spec.html#id2803362
2806. https://yaml.org/spec/1.2/spec.html#id2766150
2807. https://yaml.org/spec/1.2/spec.html#id2800401
2808. https://yaml.org/spec/1.2/spec.html#id2800967
2809. https://yaml.org/spec/1.2/spec.html#id2801301
2810. https://yaml.org/spec/1.2/spec.html#id2801681
2811. https://yaml.org/spec/1.2/spec.html#id2760395
2812. https://yaml.org/spec/1.2/spec.html#id2800401
2813. https://yaml.org/spec/1.2/spec.html#id2801301
2814. https://yaml.org/spec/1.2/spec.html#id2801522
2815. https://yaml.org/spec/1.2/spec.html#id2801681
2816. https://yaml.org/spec/1.2/spec.html#id2760395
2817. https://yaml.org/spec/1.2/spec.html#id2800401
2818. https://yaml.org/spec/1.2/spec.html#id2801681
2819. https://yaml.org/spec/1.2/spec.html#id2760844
2820. https://yaml.org/spec/1.2/spec.html#id2779048
2821. https://yaml.org/spec/1.2/spec.html#id2796251
2822. https://yaml.org/spec/1.2/spec.html#Introduction
2823. https://yaml.org/spec/1.2/spec.html#id2708649
2824. https://yaml.org/spec/1.2/spec.html#id2708710
2825. https://yaml.org/spec/1.2/spec.html#id2759572
2826. https://yaml.org/spec/1.2/spec.html#Processing
2827. https://yaml.org/spec/1.2/spec.html#id2762107
2828. https://yaml.org/spec/1.2/spec.html#id2762313
2829. https://yaml.org/spec/1.2/spec.html#id2763035
2830. https://yaml.org/spec/1.2/spec.html#id2763754
2831. https://yaml.org/spec/1.2/spec.html#id2764044
2832. https://yaml.org/spec/1.2/spec.html#id2764295
2833. https://yaml.org/spec/1.2/spec.html#id2764652
2834. https://yaml.org/spec/1.2/spec.html#id2765410
2835. https://yaml.org/spec/1.2/spec.html#id2767381
2836. https://yaml.org/spec/1.2/spec.html#id2769212
2837. https://yaml.org/spec/1.2/spec.html#id2769542
2838. https://yaml.org/spec/1.2/spec.html#id2784064
2839. https://yaml.org/spec/1.2/spec.html#Flow
2840. https://yaml.org/spec/1.2/spec.html#id2802432
2841. https://yaml.org/spec/1.2/spec.html#id2802662
2842. https://yaml.org/spec/1.2/spec.html#id2802842
2843. https://yaml.org/spec/1.2/spec.html#id2803362
2844. https://yaml.org/spec/1.2/spec.html#id2803629
2845. https://yaml.org/spec/1.2/spec.html#id2803828
2846. https://yaml.org/spec/1.2/spec.html#id2804092
2847. https://yaml.org/spec/1.2/spec.html#id2805770
2848. https://yaml.org/spec/1.2/spec.html#id2759768
2849. https://yaml.org/spec/1.2/spec.html#id2760395
2850. https://yaml.org/spec/1.2/spec.html#id2762313
2851. https://yaml.org/spec/1.2/spec.html#id2763754
2852. https://yaml.org/spec/1.2/spec.html#id2764044
2853. https://yaml.org/spec/1.2/spec.html#id2764295
2854. https://yaml.org/spec/1.2/spec.html#id2764652
2855. https://yaml.org/spec/1.2/spec.html#id2765410
2856. https://yaml.org/spec/1.2/spec.html#id2765608
2857. https://yaml.org/spec/1.2/spec.html#id2765878
2858. https://yaml.org/spec/1.2/spec.html#id2766150
2859. https://yaml.org/spec/1.2/spec.html#id2766446
2860. https://yaml.org/spec/1.2/spec.html#id2767100
2861. https://yaml.org/spec/1.2/spec.html#id2767381
2862. https://yaml.org/spec/1.2/spec.html#id2767852
2863. https://yaml.org/spec/1.2/spec.html#id2768011
2864. https://yaml.org/spec/1.2/spec.html#id2769212
2865. https://yaml.org/spec/1.2/spec.html#Syntax
2866. https://yaml.org/spec/1.2/spec.html#id2777534
2867. https://yaml.org/spec/1.2/spec.html#id2783797
2868. https://yaml.org/spec/1.2/spec.html#id2784064
2869. https://yaml.org/spec/1.2/spec.html#id2785586
2870. https://yaml.org/spec/1.2/spec.html#id2786196
2871. https://yaml.org/spec/1.2/spec.html#id2786563
2872. https://yaml.org/spec/1.2/spec.html#id2790832
2873. https://yaml.org/spec/1.2/spec.html#id2792977
2874. https://yaml.org/spec/1.2/spec.html#id2793979
2875. https://yaml.org/spec/1.2/spec.html#id2797382
2876. https://yaml.org/spec/1.2/spec.html#id2800967
2877. https://yaml.org/spec/1.2/spec.html#id2803036
2878. https://yaml.org/spec/1.2/spec.html#id2804356
2879. https://yaml.org/spec/1.2/spec.html#id2805071
2880. https://yaml.org/spec/1.2/spec.html#id2805770
2881. https://yaml.org/spec/1.2/spec.html#id2786563
2882. https://yaml.org/spec/1.2/spec.html#id2790088
2883. https://yaml.org/spec/1.2/spec.html#id2790832
2884. https://yaml.org/spec/1.2/spec.html#id2797382
2885. https://yaml.org/spec/1.2/spec.html#id2801301
2886. https://yaml.org/spec/1.2/spec.html#id2783797
2887. https://yaml.org/spec/1.2/spec.html#id2786196
2888. https://yaml.org/spec/1.2/spec.html#id2786563
2889. https://yaml.org/spec/1.2/spec.html#id2790832
2890. https://yaml.org/spec/1.2/spec.html#id2792977
2891. https://yaml.org/spec/1.2/spec.html#id2797382
2892. https://yaml.org/spec/1.2/spec.html#id2798057
2893. https://yaml.org/spec/1.2/spec.html#id2799181
2894. https://yaml.org/spec/1.2/spec.html#id2763754
2895. https://yaml.org/spec/1.2/spec.html#id2768011
2896. https://yaml.org/spec/1.2/spec.html#id2763035
2897. https://yaml.org/spec/1.2/spec.html#id2766150
2898. https://yaml.org/spec/1.2/spec.html#id2768011
2899. https://yaml.org/spec/1.2/spec.html#id2769866
2900. https://yaml.org/spec/1.2/spec.html#id2774608
2901. https://yaml.org/spec/1.2/spec.html#id2776092
2902. https://yaml.org/spec/1.2/spec.html#id2782457
2903. https://yaml.org/spec/1.2/spec.html#id2784064
2904. https://yaml.org/spec/1.2/spec.html#id2790832
2905. https://yaml.org/spec/1.2/spec.html#id2798057
2906. https://yaml.org/spec/1.2/spec.html#id2799181
2907. https://yaml.org/spec/1.2/spec.html#id2800401
2908. https://yaml.org/spec/1.2/spec.html#id2803231
2909. https://yaml.org/spec/1.2/spec.html#Processing
2910. https://yaml.org/spec/1.2/spec.html#id2762313
2911. https://yaml.org/spec/1.2/spec.html#id2763035
2912. https://yaml.org/spec/1.2/spec.html#id2764044
2913. https://yaml.org/spec/1.2/spec.html#id2764652
2914. https://yaml.org/spec/1.2/spec.html#id2766150
2915. https://yaml.org/spec/1.2/spec.html#id2766934
2916. https://yaml.org/spec/1.2/spec.html#id2770814
2917. https://yaml.org/spec/1.2/spec.html#id2775468
2918. https://yaml.org/spec/1.2/spec.html#id2784064
2919. https://yaml.org/spec/1.2/spec.html#id2786196
2920. https://yaml.org/spec/1.2/spec.html#id2798057
2921. https://yaml.org/spec/1.2/spec.html#id2804923
2922. https://yaml.org/spec/1.2/spec.html#Processing
2923. https://yaml.org/spec/1.2/spec.html#id2763452
2924. https://yaml.org/spec/1.2/spec.html#id2766150
2925. https://yaml.org/spec/1.2/spec.html#id2769866
2926. https://yaml.org/spec/1.2/spec.html#id2762313
2927. https://yaml.org/spec/1.2/spec.html#id2763035
2928. https://yaml.org/spec/1.2/spec.html#id2763452
2929. https://yaml.org/spec/1.2/spec.html#id2766150
2930. https://yaml.org/spec/1.2/spec.html#id2766446
2931. https://yaml.org/spec/1.2/spec.html#id2766934
2932. https://yaml.org/spec/1.2/spec.html#id2767100
2933. https://yaml.org/spec/1.2/spec.html#id2767222
2934. https://yaml.org/spec/1.2/spec.html#id2768011
2935. https://yaml.org/spec/1.2/spec.html#id2771184
2936. https://yaml.org/spec/1.2/spec.html#id2774608
2937. https://yaml.org/spec/1.2/spec.html#id2776092
2938. https://yaml.org/spec/1.2/spec.html#id2777534
2939. https://yaml.org/spec/1.2/spec.html#id2778241
2940. https://yaml.org/spec/1.2/spec.html#id2778481
2941. https://yaml.org/spec/1.2/spec.html#id2779048
2942. https://yaml.org/spec/1.2/spec.html#id2780069
2943. https://yaml.org/spec/1.2/spec.html#id2781147
2944. https://yaml.org/spec/1.2/spec.html#id2782457
2945. https://yaml.org/spec/1.2/spec.html#id2784064
2946. https://yaml.org/spec/1.2/spec.html#id2786942
2947. https://yaml.org/spec/1.2/spec.html#id2794534
2948. https://yaml.org/spec/1.2/spec.html#Introduction
2949. https://yaml.org/spec/1.2/spec.html#id2708710
2950. https://yaml.org/spec/1.2/spec.html#id2770814
2951. https://yaml.org/spec/1.2/spec.html#id2775170
2952. https://yaml.org/spec/1.2/spec.html#id2776092
2953. https://yaml.org/spec/1.2/spec.html#id2788097
2954. https://yaml.org/spec/1.2/spec.html#id2795688
2955. https://yaml.org/spec/1.2/spec.html#id2759768
2956. https://yaml.org/spec/1.2/spec.html#Processing
2957. https://yaml.org/spec/1.2/spec.html#id2762313
2958. https://yaml.org/spec/1.2/spec.html#id2764652
2959. https://yaml.org/spec/1.2/spec.html#id2766150
2960. https://yaml.org/spec/1.2/spec.html#id2767222
2961. https://yaml.org/spec/1.2/spec.html#id2767852
2962. https://yaml.org/spec/1.2/spec.html#id2768011
2963. https://yaml.org/spec/1.2/spec.html#id2769212
2964. https://yaml.org/spec/1.2/spec.html#id2769542
2965. https://yaml.org/spec/1.2/spec.html#id2770814
2966. https://yaml.org/spec/1.2/spec.html#id2771184
2967. https://yaml.org/spec/1.2/spec.html#id2774608
2968. https://yaml.org/spec/1.2/spec.html#id2775468
2969. https://yaml.org/spec/1.2/spec.html#id2780069
2970. https://yaml.org/spec/1.2/spec.html#id2781147
2971. https://yaml.org/spec/1.2/spec.html#id2781553
2972. https://yaml.org/spec/1.2/spec.html#id2782457
2973. https://yaml.org/spec/1.2/spec.html#id2784064
2974. https://yaml.org/spec/1.2/spec.html#id2785586
2975. https://yaml.org/spec/1.2/spec.html#id2790832
2976. https://yaml.org/spec/1.2/spec.html#id2793979
2977. https://yaml.org/spec/1.2/spec.html#id2802346
2978. https://yaml.org/spec/1.2/spec.html#id2803231
2979. https://yaml.org/spec/1.2/spec.html#id2803828
2980. https://yaml.org/spec/1.2/spec.html#id2804092
2981. https://yaml.org/spec/1.2/spec.html#id2804356
2982. https://yaml.org/spec/1.2/spec.html#id2804923
2983. https://yaml.org/spec/1.2/spec.html#id2805770
2984. https://yaml.org/spec/1.2/spec.html#Introduction
2985. https://yaml.org/spec/1.2/spec.html#id2708710
2986. https://yaml.org/spec/1.2/spec.html#id2762313
2987. https://yaml.org/spec/1.2/spec.html#id2764295
2988. https://yaml.org/spec/1.2/spec.html#id2764652
2989. https://yaml.org/spec/1.2/spec.html#id2765608
2990. https://yaml.org/spec/1.2/spec.html#id2802432
2991. https://yaml.org/spec/1.2/spec.html#id2802662
2992. https://yaml.org/spec/1.2/spec.html#id2802842
2993. https://yaml.org/spec/1.2/spec.html#id2803362
2994. https://yaml.org/spec/1.2/spec.html#id2803629
2995. https://yaml.org/spec/1.2/spec.html#id2803828
2996. https://yaml.org/spec/1.2/spec.html#id2804092
2997. https://yaml.org/spec/1.2/spec.html#id2805770
2998. https://yaml.org/spec/1.2/spec.html#Processing
2999. https://yaml.org/spec/1.2/spec.html#id2762107
3000. https://yaml.org/spec/1.2/spec.html#id2762313
3001. https://yaml.org/spec/1.2/spec.html#id2763035
3002. https://yaml.org/spec/1.2/spec.html#id2763452
3003. https://yaml.org/spec/1.2/spec.html#id2763754
3004. https://yaml.org/spec/1.2/spec.html#id2764044
3005. https://yaml.org/spec/1.2/spec.html#id2764652
3006. https://yaml.org/spec/1.2/spec.html#id2765410
3007. https://yaml.org/spec/1.2/spec.html#id2765608
3008. https://yaml.org/spec/1.2/spec.html#id2765878
3009. https://yaml.org/spec/1.2/spec.html#id2766150
3010. https://yaml.org/spec/1.2/spec.html#id2766446
3011. https://yaml.org/spec/1.2/spec.html#id2766934
3012. https://yaml.org/spec/1.2/spec.html#id2767100
3013. https://yaml.org/spec/1.2/spec.html#id2767222
3014. https://yaml.org/spec/1.2/spec.html#id2769542
3015. https://yaml.org/spec/1.2/spec.html#id2785586
3016. https://yaml.org/spec/1.2/spec.html#id2767381
3017. https://yaml.org/spec/1.2/spec.html#id2768011
3018. https://yaml.org/spec/1.2/spec.html#id2769212
3019. https://yaml.org/spec/1.2/spec.html#id2769542
3020. https://yaml.org/spec/1.2/spec.html#id2767381
3021. https://yaml.org/spec/1.2/spec.html#id2768011
3022. https://yaml.org/spec/1.2/spec.html#id2769212
3023. https://yaml.org/spec/1.2/spec.html#id2803036
3024. https://yaml.org/spec/1.2/spec.html#id2759768
3025. https://yaml.org/spec/1.2/spec.html#Introduction
3026. https://yaml.org/spec/1.2/spec.html#id2708710
3027. https://yaml.org/spec/1.2/spec.html#id2760844
3028. https://yaml.org/spec/1.2/spec.html#id2762313
3029. https://yaml.org/spec/1.2/spec.html#id2763754
3030. https://yaml.org/spec/1.2/spec.html#id2764044
3031. https://yaml.org/spec/1.2/spec.html#id2764295
3032. https://yaml.org/spec/1.2/spec.html#id2764652
3033. https://yaml.org/spec/1.2/spec.html#id2766934
3034. https://yaml.org/spec/1.2/spec.html#id2767100
3035. https://yaml.org/spec/1.2/spec.html#id2769212
3036. https://yaml.org/spec/1.2/spec.html#id2774608
3037. https://yaml.org/spec/1.2/spec.html#id2778241
3038. https://yaml.org/spec/1.2/spec.html#id2778481
3039. https://yaml.org/spec/1.2/spec.html#id2780069
3040. https://yaml.org/spec/1.2/spec.html#id2786563
3041. https://yaml.org/spec/1.2/spec.html#id2794534
3042. https://yaml.org/spec/1.2/spec.html#id2802432
3043. https://yaml.org/spec/1.2/spec.html#id2802842
3044. https://yaml.org/spec/1.2/spec.html#id2803362
3045. https://yaml.org/spec/1.2/spec.html#id2803629
3046. https://yaml.org/spec/1.2/spec.html#id2803828
3047. https://yaml.org/spec/1.2/spec.html#id2804092
3048. https://yaml.org/spec/1.2/spec.html#id2804356
3049. https://yaml.org/spec/1.2/spec.html#id2805071
3050. https://yaml.org/spec/1.2/spec.html#id2708710
3051. https://yaml.org/spec/1.2/spec.html#id2764295
3052. https://yaml.org/spec/1.2/spec.html#id2764652
3053. https://yaml.org/spec/1.2/spec.html#id2766934
3054. https://yaml.org/spec/1.2/spec.html#id2767381
3055. https://yaml.org/spec/1.2/spec.html#id2762313
3056. https://yaml.org/spec/1.2/spec.html#id2763035
3057. https://yaml.org/spec/1.2/spec.html#id2764295
3058. https://yaml.org/spec/1.2/spec.html#id2764652
3059. https://yaml.org/spec/1.2/spec.html#id2766150
3060. https://yaml.org/spec/1.2/spec.html#id2766934
3061. https://yaml.org/spec/1.2/spec.html#id2767381
3062. https://yaml.org/spec/1.2/spec.html#Schema
3063. https://yaml.org/spec/1.2/spec.html#id2802346
3064. https://yaml.org/spec/1.2/spec.html#id2803231
3065. https://yaml.org/spec/1.2/spec.html#id2803311
3066. https://yaml.org/spec/1.2/spec.html#id2804923
3067. https://yaml.org/spec/1.2/spec.html#id2805019
3068. https://yaml.org/spec/1.2/spec.html#id2805770
3069. https://yaml.org/spec/1.2/spec.html#id2804923
3070. https://yaml.org/spec/1.2/spec.html#id2805071
3071. https://yaml.org/spec/1.2/spec.html#id2805770
3072. https://yaml.org/spec/1.2/spec.html#id2761292
3073. https://yaml.org/spec/1.2/spec.html#id2802346
3074. https://yaml.org/spec/1.2/spec.html#id2803311
3075. https://yaml.org/spec/1.2/spec.html#id2804356
3076. https://yaml.org/spec/1.2/spec.html#id2761292
3077. https://yaml.org/spec/1.2/spec.html#id2803231
3078. https://yaml.org/spec/1.2/spec.html#id2804356
3079. https://yaml.org/spec/1.2/spec.html#id2804923
3080. https://yaml.org/spec/1.2/spec.html#id2805019
3081. https://yaml.org/spec/1.2/spec.html#id2805071
3082. https://yaml.org/spec/1.2/spec.html#Introduction
3083. https://yaml.org/spec/1.2/spec.html#id2708710
3084. https://yaml.org/spec/1.2/spec.html#id2762313
3085. https://yaml.org/spec/1.2/spec.html#id2763754
3086. https://yaml.org/spec/1.2/spec.html#id2764044
3087. https://yaml.org/spec/1.2/spec.html#id2764295
3088. https://yaml.org/spec/1.2/spec.html#id2764652
3089. https://yaml.org/spec/1.2/spec.html#id2765608
3090. https://yaml.org/spec/1.2/spec.html#id2768011
3091. https://yaml.org/spec/1.2/spec.html#id2790832
3092. https://yaml.org/spec/1.2/spec.html#id2802662
3093. https://yaml.org/spec/1.2/spec.html#Processing
3094. https://yaml.org/spec/1.2/spec.html#id2762107
3095. https://yaml.org/spec/1.2/spec.html#id2762313
3096. https://yaml.org/spec/1.2/spec.html#id2763035
3097. https://yaml.org/spec/1.2/spec.html#id2763452
3098. https://yaml.org/spec/1.2/spec.html#id2765410
3099. https://yaml.org/spec/1.2/spec.html#id2765878
3100. https://yaml.org/spec/1.2/spec.html#id2766150
3101. https://yaml.org/spec/1.2/spec.html#id2766446
3102. https://yaml.org/spec/1.2/spec.html#id2766934
3103. https://yaml.org/spec/1.2/spec.html#id2767100
3104. https://yaml.org/spec/1.2/spec.html#id2767222
3105. https://yaml.org/spec/1.2/spec.html#id2785586
3106. https://yaml.org/spec/1.2/spec.html#id2762313
3107. https://yaml.org/spec/1.2/spec.html#id2763035
3108. https://yaml.org/spec/1.2/spec.html#id2763452
3109. https://yaml.org/spec/1.2/spec.html#id2765608
3110. https://yaml.org/spec/1.2/spec.html#id2765878
3111. https://yaml.org/spec/1.2/spec.html#id2785586
3112. https://yaml.org/spec/1.2/spec.html#Introduction
3113. https://yaml.org/spec/1.2/spec.html#id2708710
3114. https://yaml.org/spec/1.2/spec.html#id2759572
3115. https://yaml.org/spec/1.2/spec.html#id2762313
3116. https://yaml.org/spec/1.2/spec.html#id2763035
3117. https://yaml.org/spec/1.2/spec.html#id2765608
3118. https://yaml.org/spec/1.2/spec.html#id2765878
3119. https://yaml.org/spec/1.2/spec.html#id2786196
3120. https://yaml.org/spec/1.2/spec.html#id2759768
3121. https://yaml.org/spec/1.2/spec.html#id2708710
3122. https://yaml.org/spec/1.2/spec.html#id2760844
3123. https://yaml.org/spec/1.2/spec.html#id2775170
3124. https://yaml.org/spec/1.2/spec.html#id2777534
3125. https://yaml.org/spec/1.2/spec.html#id2779048
3126. https://yaml.org/spec/1.2/spec.html#id2788097
3127. https://yaml.org/spec/1.2/spec.html#id2788859
3128. https://yaml.org/spec/1.2/spec.html#id2793979
3129. https://yaml.org/spec/1.2/spec.html#id2796251
3130. https://yaml.org/spec/1.2/spec.html#id2797382
3131. https://yaml.org/spec/1.2/spec.html#id2799181
3132. https://yaml.org/spec/1.2/spec.html#id2800967
3133. https://yaml.org/spec/1.2/spec.html#Introduction
3134. https://yaml.org/spec/1.2/spec.html#id2708710
3135. https://yaml.org/spec/1.2/spec.html#id2759963
3136. https://yaml.org/spec/1.2/spec.html#id2762313
3137. https://yaml.org/spec/1.2/spec.html#id2763035
3138. https://yaml.org/spec/1.2/spec.html#id2763452
3139. https://yaml.org/spec/1.2/spec.html#id2766446
3140. https://yaml.org/spec/1.2/spec.html#id2768011
3141. https://yaml.org/spec/1.2/spec.html#id2769866
3142. https://yaml.org/spec/1.2/spec.html#id2770517
3143. https://yaml.org/spec/1.2/spec.html#id2777534
3144. https://yaml.org/spec/1.2/spec.html#id2778241
3145. https://yaml.org/spec/1.2/spec.html#id2778481
3146. https://yaml.org/spec/1.2/spec.html#id2779048
3147. https://yaml.org/spec/1.2/spec.html#id2780069
3148. https://yaml.org/spec/1.2/spec.html#id2780810
3149. https://yaml.org/spec/1.2/spec.html#id2781147
3150. https://yaml.org/spec/1.2/spec.html#Block
3151. https://yaml.org/spec/1.2/spec.html#id2793979
3152. https://yaml.org/spec/1.2/spec.html#id2794534
3153. https://yaml.org/spec/1.2/spec.html#id2795688
3154. https://yaml.org/spec/1.2/spec.html#id2797382
3155. https://yaml.org/spec/1.2/spec.html#id2799181
3156. https://yaml.org/spec/1.2/spec.html#id2800967
3157. https://yaml.org/spec/1.2/spec.html#id2778241
3158. https://yaml.org/spec/1.2/spec.html#id2780069
3159. https://yaml.org/spec/1.2/spec.html#id2790832
3160. https://yaml.org/spec/1.2/spec.html#id2797382
3161. https://yaml.org/spec/1.2/spec.html#id2770517
3162. https://yaml.org/spec/1.2/spec.html#id2775170
3163. https://yaml.org/spec/1.2/spec.html#id2778241
3164. https://yaml.org/spec/1.2/spec.html#id2778481
3165. https://yaml.org/spec/1.2/spec.html#id2779048
3166. https://yaml.org/spec/1.2/spec.html#id2780069
3167. https://yaml.org/spec/1.2/spec.html#id2787109
3168. https://yaml.org/spec/1.2/spec.html#id2788097
3169. https://yaml.org/spec/1.2/spec.html#id2788859
3170. https://yaml.org/spec/1.2/spec.html#id2790832
3171. https://yaml.org/spec/1.2/spec.html#id2795688
3172. https://yaml.org/spec/1.2/spec.html#id2796251
3173. https://yaml.org/spec/1.2/spec.html#id2797382
3174. https://yaml.org/spec/1.2/spec.html#id2708710
3175. https://yaml.org/spec/1.2/spec.html#Processing
3176. https://yaml.org/spec/1.2/spec.html#id2762107
3177. https://yaml.org/spec/1.2/spec.html#id2762313
3178. https://yaml.org/spec/1.2/spec.html#id2763035
3179. https://yaml.org/spec/1.2/spec.html#id2766150
3180. https://yaml.org/spec/1.2/spec.html#id2767381
3181. https://yaml.org/spec/1.2/spec.html#id2767852
3182. https://yaml.org/spec/1.2/spec.html#id2768011
3183. https://yaml.org/spec/1.2/spec.html#Syntax
3184. https://yaml.org/spec/1.2/spec.html#id2770814
3185. https://yaml.org/spec/1.2/spec.html#id2771184
3186. https://yaml.org/spec/1.2/spec.html#id2775468
3187. https://yaml.org/spec/1.2/spec.html#id2780069
3188. https://yaml.org/spec/1.2/spec.html#id2783273
3189. https://yaml.org/spec/1.2/spec.html#id2786563
3190. https://yaml.org/spec/1.2/spec.html#id2800132
3191. https://yaml.org/spec/1.2/spec.html#id2801681
3192. https://yaml.org/spec/1.2/spec.html#id2763035
3193. https://yaml.org/spec/1.2/spec.html#id2767381
3194. https://yaml.org/spec/1.2/spec.html#id2767852
3195. https://yaml.org/spec/1.2/spec.html#id2767852
3196. https://yaml.org/spec/1.2/spec.html#id2801681
3197. https://yaml.org/spec/1.2/spec.html#id2762313
3198. https://yaml.org/spec/1.2/spec.html#id2763035
3199. https://yaml.org/spec/1.2/spec.html#id2763452
3200. https://yaml.org/spec/1.2/spec.html#id2766150
3201. https://yaml.org/spec/1.2/spec.html#id2766446
3202. https://yaml.org/spec/1.2/spec.html#id2766934
3203. https://yaml.org/spec/1.2/spec.html#id2768011
3204. https://yaml.org/spec/1.2/spec.html#id2784064
3205. https://yaml.org/spec/1.2/spec.html#id2787109
3206. https://yaml.org/spec/1.2/spec.html#id2788859
3207. https://yaml.org/spec/1.2/spec.html#id2708710
3208. https://yaml.org/spec/1.2/spec.html#id2760844
3209. https://yaml.org/spec/1.2/spec.html#id2766446
3210. https://yaml.org/spec/1.2/spec.html#id2769866
3211. https://yaml.org/spec/1.2/spec.html#id2777534
3212. https://yaml.org/spec/1.2/spec.html#Block
3213. https://yaml.org/spec/1.2/spec.html#id2797382
3214. https://yaml.org/spec/1.2/spec.html#id2759963
3215. https://yaml.org/spec/1.2/spec.html#id2760395
3216. https://yaml.org/spec/1.2/spec.html#id2777534
3217. https://yaml.org/spec/1.2/spec.html#id2790088
3218. https://yaml.org/spec/1.2/spec.html#id2797293
3219. https://yaml.org/spec/1.2/spec.html#id2797382
3220. https://yaml.org/spec/1.2/spec.html#id2799181
3221. https://yaml.org/spec/1.2/spec.html#id2760844
3222. https://yaml.org/spec/1.2/spec.html#id2766446
3223. https://yaml.org/spec/1.2/spec.html#id2772075
3224. https://yaml.org/spec/1.2/spec.html#id2779048
3225. https://yaml.org/spec/1.2/spec.html#id2793652
3226. https://yaml.org/spec/1.2/spec.html#id2795688
3227. https://yaml.org/spec/1.2/spec.html#id2796251
3228. https://yaml.org/spec/1.2/spec.html#id2708710
3229. https://yaml.org/spec/1.2/spec.html#id2760844
3230. https://yaml.org/spec/1.2/spec.html#id2766446
3231. https://yaml.org/spec/1.2/spec.html#id2772075
3232. https://yaml.org/spec/1.2/spec.html#id2793652
3233. https://yaml.org/spec/1.2/spec.html#id2795688
3234. https://yaml.org/spec/1.2/spec.html#id2796251
3235. https://yaml.org/spec/1.2/spec.html#id2766446
3236. https://yaml.org/spec/1.2/spec.html#id2769866
3237. https://yaml.org/spec/1.2/spec.html#id2798057
3238. https://yaml.org/spec/1.2/spec.html#id2799181
3239. https://yaml.org/spec/1.2/spec.html#id2766446
3240. https://yaml.org/spec/1.2/spec.html#id2793652
3241. https://yaml.org/spec/1.2/spec.html#id2793718
3242. https://yaml.org/spec/1.2/spec.html#id2793979
3243. https://yaml.org/spec/1.2/spec.html#id2794534
3244. https://yaml.org/spec/1.2/spec.html#id2759963
3245. https://yaml.org/spec/1.2/spec.html#id2766446
3246. https://yaml.org/spec/1.2/spec.html#id2769866
3247. https://yaml.org/spec/1.2/spec.html#id2772075
3248. https://yaml.org/spec/1.2/spec.html#id2797382
3249. https://yaml.org/spec/1.2/spec.html#id2798057
3250. https://yaml.org/spec/1.2/spec.html#id2799181
3251. https://yaml.org/spec/1.2/spec.html#id2766446
3252. https://yaml.org/spec/1.2/spec.html#id2797382
3253. https://yaml.org/spec/1.2/spec.html#id2798057
3254. https://yaml.org/spec/1.2/spec.html#id2708710
3255. https://yaml.org/spec/1.2/spec.html#id2759963
3256. https://yaml.org/spec/1.2/spec.html#id2760844
3257. https://yaml.org/spec/1.2/spec.html#id2766446
3258. https://yaml.org/spec/1.2/spec.html#id2769866
3259. https://yaml.org/spec/1.2/spec.html#id2779048
3260. https://yaml.org/spec/1.2/spec.html#Flow
3261. https://yaml.org/spec/1.2/spec.html#id2790320
3262. https://yaml.org/spec/1.2/spec.html#id2792977
3263. https://yaml.org/spec/1.2/spec.html#id2799181
3264. https://yaml.org/spec/1.2/spec.html#Syntax
3265. https://yaml.org/spec/1.2/spec.html#id2769866
3266. https://yaml.org/spec/1.2/spec.html#id2772075
3267. https://yaml.org/spec/1.2/spec.html#id2775468
3268. https://yaml.org/spec/1.2/spec.html#id2784064
3269. https://yaml.org/spec/1.2/spec.html#id2785586
3270. https://yaml.org/spec/1.2/spec.html#id2788859
3271. https://yaml.org/spec/1.2/spec.html#id2790088
3272. https://yaml.org/spec/1.2/spec.html#id2708710
3273. https://yaml.org/spec/1.2/spec.html#id2760844
3274. https://yaml.org/spec/1.2/spec.html#id2766446
3275. https://yaml.org/spec/1.2/spec.html#Syntax
3276. https://yaml.org/spec/1.2/spec.html#id2770814
3277. https://yaml.org/spec/1.2/spec.html#id2771184
3278. https://yaml.org/spec/1.2/spec.html#id2772075
3279. https://yaml.org/spec/1.2/spec.html#id2776092
3280. https://yaml.org/spec/1.2/spec.html#id2786942
3281. https://yaml.org/spec/1.2/spec.html#id2787109
3282. https://yaml.org/spec/1.2/spec.html#id2792977
3283. https://yaml.org/spec/1.2/spec.html#id2759963
3284. https://yaml.org/spec/1.2/spec.html#id2766446
3285. https://yaml.org/spec/1.2/spec.html#id2769866
3286. https://yaml.org/spec/1.2/spec.html#id2772075
3287. https://yaml.org/spec/1.2/spec.html#id2790832
3288. https://yaml.org/spec/1.2/spec.html#id2798057
3289. https://yaml.org/spec/1.2/spec.html#id2760844
3290. https://yaml.org/spec/1.2/spec.html#id2766446
3291. https://yaml.org/spec/1.2/spec.html#id2768011
3292. https://yaml.org/spec/1.2/spec.html#id2769866
3293. https://yaml.org/spec/1.2/spec.html#id2772075
3294. https://yaml.org/spec/1.2/spec.html#id2784064
3295. https://yaml.org/spec/1.2/spec.html#id2786563
3296. https://yaml.org/spec/1.2/spec.html#id2786942
3297. https://yaml.org/spec/1.2/spec.html#id2788859
3298. https://yaml.org/spec/1.2/spec.html#id2790832
3299. https://yaml.org/spec/1.2/spec.html#id2792977
3300. https://yaml.org/spec/1.2/spec.html#id2797293
3301. https://yaml.org/spec/1.2/spec.html#id2797382
3302. https://yaml.org/spec/1.2/spec.html#id2798057
3303. https://yaml.org/spec/1.2/spec.html#id2799181
3304. https://yaml.org/spec/1.2/spec.html#id2800401
3305. https://yaml.org/spec/1.2/spec.html#id2804356
3306. https://yaml.org/spec/1.2/spec.html#id2805071
3307. https://yaml.org/spec/1.2/spec.html#id2760844
3308. https://yaml.org/spec/1.2/spec.html#id2766446
3309. https://yaml.org/spec/1.2/spec.html#id2778481
3310. https://yaml.org/spec/1.2/spec.html#id2779048
3311. https://yaml.org/spec/1.2/spec.html#id2786942
3312. https://yaml.org/spec/1.2/spec.html#id2759963
3313. https://yaml.org/spec/1.2/spec.html#id2766446
3314. https://yaml.org/spec/1.2/spec.html#id2772075
3315. https://yaml.org/spec/1.2/spec.html#id2790320
3316. https://yaml.org/spec/1.2/spec.html#id2790832
3317. https://yaml.org/spec/1.2/spec.html#id2766446
3318. https://yaml.org/spec/1.2/spec.html#id2769866
3319. https://yaml.org/spec/1.2/spec.html#id2772075
3320. https://yaml.org/spec/1.2/spec.html#id2786942
3321. https://yaml.org/spec/1.2/spec.html#id2788097
3322. https://yaml.org/spec/1.2/spec.html#id2766446
3323. https://yaml.org/spec/1.2/spec.html#id2776092
3324. https://yaml.org/spec/1.2/spec.html#id2778853
3325. https://yaml.org/spec/1.2/spec.html#id2786942
3326. https://yaml.org/spec/1.2/spec.html#id2795688
3327. https://yaml.org/spec/1.2/spec.html#id2765608
3328. https://yaml.org/spec/1.2/spec.html#id2766446
3329. https://yaml.org/spec/1.2/spec.html#id2790320
3330. https://yaml.org/spec/1.2/spec.html#id2790832
3331. https://yaml.org/spec/1.2/spec.html#id2798057
3332. https://yaml.org/spec/1.2/spec.html#id2708710
3333. https://yaml.org/spec/1.2/spec.html#id2770814
3334. https://yaml.org/spec/1.2/spec.html#id2775170
3335. https://yaml.org/spec/1.2/spec.html#id2777534
3336. https://yaml.org/spec/1.2/spec.html#id2778241
3337. https://yaml.org/spec/1.2/spec.html#id2778481
3338. https://yaml.org/spec/1.2/spec.html#id2793979
3339. https://yaml.org/spec/1.2/spec.html#id2708710
3340. https://yaml.org/spec/1.2/spec.html#id2761292
3341. https://yaml.org/spec/1.2/spec.html#id2762313
3342. https://yaml.org/spec/1.2/spec.html#id2763754
3343. https://yaml.org/spec/1.2/spec.html#id2764044
3344. https://yaml.org/spec/1.2/spec.html#id2764295
3345. https://yaml.org/spec/1.2/spec.html#id2764652
3346. https://yaml.org/spec/1.2/spec.html#id2766934
3347. https://yaml.org/spec/1.2/spec.html#id2767381
3348. https://yaml.org/spec/1.2/spec.html#id2768011
3349. https://yaml.org/spec/1.2/spec.html#id2769212
3350. https://yaml.org/spec/1.2/spec.html#id2769542
3351. https://yaml.org/spec/1.2/spec.html#Syntax
3352. https://yaml.org/spec/1.2/spec.html#id2769866
3353. https://yaml.org/spec/1.2/spec.html#id2772075
3354. https://yaml.org/spec/1.2/spec.html#id2775468
3355. https://yaml.org/spec/1.2/spec.html#id2782090
3356. https://yaml.org/spec/1.2/spec.html#id2783273
3357. https://yaml.org/spec/1.2/spec.html#id2783797
3358. https://yaml.org/spec/1.2/spec.html#id2784064
3359. https://yaml.org/spec/1.2/spec.html#Flow
3360. https://yaml.org/spec/1.2/spec.html#Schema
3361. https://yaml.org/spec/1.2/spec.html#id2803311
3362. https://yaml.org/spec/1.2/spec.html#id2805019
3363. https://yaml.org/spec/1.2/spec.html#id2805770
3364. https://yaml.org/spec/1.2/spec.html#id2769542
3365. https://yaml.org/spec/1.2/spec.html#id2708710
3366. https://yaml.org/spec/1.2/spec.html#id2761292
3367. https://yaml.org/spec/1.2/spec.html#id2762313
3368. https://yaml.org/spec/1.2/spec.html#id2764295
3369. https://yaml.org/spec/1.2/spec.html#id2768011
3370. https://yaml.org/spec/1.2/spec.html#id2782457
3371. https://yaml.org/spec/1.2/spec.html#id2783273
3372. https://yaml.org/spec/1.2/spec.html#id2784064
3373. https://yaml.org/spec/1.2/spec.html#id2805770
3374. https://yaml.org/spec/1.2/spec.html#id2761292
3375. https://yaml.org/spec/1.2/spec.html#id2762107
3376. https://yaml.org/spec/1.2/spec.html#id2762313
3377. https://yaml.org/spec/1.2/spec.html#id2772075
3378. https://yaml.org/spec/1.2/spec.html#id2782090
3379. https://yaml.org/spec/1.2/spec.html#id2782457
3380. https://yaml.org/spec/1.2/spec.html#id2783273
3381. https://yaml.org/spec/1.2/spec.html#id2784064
3382. https://yaml.org/spec/1.2/spec.html#id2775468
3383. https://yaml.org/spec/1.2/spec.html#id2782457
3384. https://yaml.org/spec/1.2/spec.html#id2784064
3385. https://yaml.org/spec/1.2/spec.html#id2782457
3386. https://yaml.org/spec/1.2/spec.html#id2782457
3387. https://yaml.org/spec/1.2/spec.html#id2708710
3388. https://yaml.org/spec/1.2/spec.html#id2761292
3389. https://yaml.org/spec/1.2/spec.html#id2762313
3390. https://yaml.org/spec/1.2/spec.html#id2764295
3391. https://yaml.org/spec/1.2/spec.html#id2768011
3392. https://yaml.org/spec/1.2/spec.html#id2772075
3393. https://yaml.org/spec/1.2/spec.html#id2782457
3394. https://yaml.org/spec/1.2/spec.html#id2783273
3395. https://yaml.org/spec/1.2/spec.html#id2784064
3396. https://yaml.org/spec/1.2/spec.html#id2805770
3397. https://yaml.org/spec/1.2/spec.html#id2761292
3398. https://yaml.org/spec/1.2/spec.html#id2762313
3399. https://yaml.org/spec/1.2/spec.html#id2767381
3400. https://yaml.org/spec/1.2/spec.html#id2768011
3401. https://yaml.org/spec/1.2/spec.html#id2772075
3402. https://yaml.org/spec/1.2/spec.html#id2784064
3403. https://yaml.org/spec/1.2/spec.html#Schema
3404. https://yaml.org/spec/1.2/spec.html#id2804356
3405. https://yaml.org/spec/1.2/spec.html#id2805071
3406. https://yaml.org/spec/1.2/spec.html#id2805770
3407. https://yaml.org/spec/1.2/spec.html#id2782090
3408. https://yaml.org/spec/1.2/spec.html#id2783273
3409. https://yaml.org/spec/1.2/spec.html#id2784064
3410. https://yaml.org/spec/1.2/spec.html#id2768011
3411. https://yaml.org/spec/1.2/spec.html#id2772075
3412. https://yaml.org/spec/1.2/spec.html#id2784064
3413. https://yaml.org/spec/1.2/spec.html#id2769212
3414. https://yaml.org/spec/1.2/spec.html#id2761292
3415. https://yaml.org/spec/1.2/spec.html#id2782457
3416. https://yaml.org/spec/1.2/spec.html#id2805770
3417. https://yaml.org/spec/1.2/spec.html#id2803629
3418. https://yaml.org/spec/1.2/spec.html#id2761292
3419. https://yaml.org/spec/1.2/spec.html#id2804092
3420. https://yaml.org/spec/1.2/spec.html#id2761292
3421. https://yaml.org/spec/1.2/spec.html#id2803828
3422. https://yaml.org/spec/1.2/spec.html#id2761292
3423. https://yaml.org/spec/1.2/spec.html#id2802432
3424. https://yaml.org/spec/1.2/spec.html#id2761292
3425. https://yaml.org/spec/1.2/spec.html#id2786563
3426. https://yaml.org/spec/1.2/spec.html#id2803362
3427. https://yaml.org/spec/1.2/spec.html#id2761292
3428. https://yaml.org/spec/1.2/spec.html#id2802662
3429. https://yaml.org/spec/1.2/spec.html#id2761292
3430. https://yaml.org/spec/1.2/spec.html#id2802842
3431. https://yaml.org/spec/1.2/spec.html#id2764295
3432. https://yaml.org/spec/1.2/spec.html#id2767381
3433. https://yaml.org/spec/1.2/spec.html#id2768011
3434. https://yaml.org/spec/1.2/spec.html#id2784064
3435. https://yaml.org/spec/1.2/spec.html#id2786942
3436. https://yaml.org/spec/1.2/spec.html#Schema
3437. https://yaml.org/spec/1.2/spec.html#id2803036
3438. https://yaml.org/spec/1.2/spec.html#id2804356
3439. https://yaml.org/spec/1.2/spec.html#id2805071
3440. https://yaml.org/spec/1.2/spec.html#id2805770
3441. https://yaml.org/spec/1.2/spec.html#id2768011
3442. https://yaml.org/spec/1.2/spec.html#id2784064
3443. https://yaml.org/spec/1.2/spec.html#id2803036
3444. https://yaml.org/spec/1.2/spec.html#id2804356
3445. https://yaml.org/spec/1.2/spec.html#id2805071
3446. https://yaml.org/spec/1.2/spec.html#id2761292
3447. https://yaml.org/spec/1.2/spec.html#id2775468
3448. https://yaml.org/spec/1.2/spec.html#id2782090
3449. https://yaml.org/spec/1.2/spec.html#id2782457
3450. https://yaml.org/spec/1.2/spec.html#id2783273
3451. https://yaml.org/spec/1.2/spec.html#id2784064
3452. https://yaml.org/spec/1.2/spec.html#id2768011
3453. https://yaml.org/spec/1.2/spec.html#id2784064
3454. https://yaml.org/spec/1.2/spec.html#id2763035
3455. https://yaml.org/spec/1.2/spec.html#id2767381
3456. https://yaml.org/spec/1.2/spec.html#id2769542
3457. https://yaml.org/spec/1.2/spec.html#id2767381
3458. https://yaml.org/spec/1.2/spec.html#id2769212
3459. https://yaml.org/spec/1.2/spec.html#id2767381
3460. https://yaml.org/spec/1.2/spec.html#id2768011
3461. https://yaml.org/spec/1.2/spec.html#id2784064
3462. https://yaml.org/spec/1.2/spec.html#id2779048
3463. https://yaml.org/spec/1.2/spec.html#id2762313
3464. https://yaml.org/spec/1.2/spec.html#id2764044
3465. https://yaml.org/spec/1.2/spec.html#id2764652
3466. https://yaml.org/spec/1.2/spec.html#id2768011
3467. https://yaml.org/spec/1.2/spec.html#id2772075
3468. https://yaml.org/spec/1.2/spec.html#id2790832
3469. https://yaml.org/spec/1.2/spec.html#id2798057
3470. https://yaml.org/spec/1.2/spec.html#id2802432
3471. https://yaml.org/spec/1.2/spec.html#id2803362
3472. https://yaml.org/spec/1.2/spec.html#id2774608
3473. https://yaml.org/spec/1.2/spec.html#id2781553