-
  name: Mark McGwire
  hr:   65
  avg:  0.278
-
  name: Sammy Sosa
  hr:   63
  avg:  0.288

$doc1 = [
  { avg => 0.278, hr => 65, name => "Mark McGwire" },
  { avg => 0.288, hr => 63, name => "Sammy Sosa" },
]

Doc 1: [
   {
      "avg" : 0.278,
      "hr" : 65,
      "name" : "Mark McGwire"
   },
   {
      "avg" : 0.288,
      "hr" : 63,
      "name" : "Sammy Sosa"
   }
]

---
- avg: 0.278
  hr: 65
  name: Mark McGwire
- avg: 0.288
  hr: 63
  name: Sammy Sosa

- name: Mark McGwire
  hr: 65
  avg: 0.278
- name: Sammy Sosa
  hr: 63
  avg: 0.288

"top1" : 
  "key1" : &alias1 scalar1
'top2' : 
  'key2' : &alias2 scalar2
top3: &node3 
  *alias1 : scalar3
top4: 
  *alias2 : scalar4
top5   :    
  scalar5
top6: 
  &anchor6 'key6' : scalar6

$doc1 = {
  top1 => { key1 => "scalar1" },
  top2 => { key2 => "scalar2" },
  top3 => { scalar1 => "scalar3" },
  top4 => { scalar2 => "scalar4" },
  top5 => "scalar5",
  top6 => { key6 => "scalar6" },
}

Doc 1: {
   "top1" : {
      "key1" : "scalar1"
   },
   "top2" : {
      "key2" : "scalar2"
   },
   "top3" : {
      "scalar1" : "scalar3"
   },
   "top4" : {
      "scalar2" : "scalar4"
   },
   "top5" : "scalar5",
   "top6" : {
      "key6" : "scalar6"
   }
}

---
top1:
  key1: scalar1
top2:
  key2: scalar2
top3:
  scalar1: scalar3
top4:
  scalar2: scalar4
top5: scalar5
top6:
  key6: scalar6

"top1":
  "key1": &alias1 scalar1
'top2':
  'key2': &alias2 scalar2
top3: &node3
  *alias1 : scalar3
top4:
  *alias2 : scalar4
top5: scalar5
top6:
  &anchor6 'key6': scalar6

%YAML 1.2
--- text

$doc1 = "text"

Doc 1: "text"

--- text

%YAML 1.2
--- text

 - !!str a
 - b
 - !!int 42
 - d

$doc1 = ["a", "b", 42, "d"]

Doc 1: [
   "a",
   "b",
   42,
   "d"
]

---
- a
- b
- 42
- d

- !!str a
- b
- !!int 42
- d

a!"#$%&'()*+,-./09:;<=>?@AZ[\]^_`az{|}~: safe
?foo: safe question mark
:foo: safe colon
-foo: safe dash
this is#not: a comment

$doc1 = {
  "-foo" => "safe dash",
  ":foo" => "safe colon",
  "?foo" => "safe question mark",
  "a!\"#\$%&'()*+,-./09:;<=>?\@AZ[\\]^_`az{|}~" => "safe",
  "this is#not" => "a comment",
}

Doc 1: {
   "-foo" : "safe dash",
   ":foo" : "safe colon",
   "?foo" : "safe question mark",
   "a!\"#$%&'()*+,-./09:;<=>?@AZ[\\]^_`az{|}~" : "safe",
   "this is#not" : "a comment"
}

---
-foo: safe dash
:foo: safe colon
?foo: safe question mark
a!"#$%&'()*+,-./09:;<=>?@AZ[\]^_`az{|}~: safe
this is#not: a comment

a!"#$%&'()*+,-./09:;<=>?@AZ[\]^_`az{|}~: safe
?foo: safe question mark
:foo: safe colon
-foo: safe dash
this is#not: a comment

--- |1-

$doc1 = ""

Doc 1: ""

--- ''

--- ""

--- |1+

$doc1 = ""

Doc 1: ""

--- ''

--- ""

: a
: b

Duplicate key '' at YAML/PP/Parser.pm line 61.
 at YAML/PP/Loader.pm line 94.

: a
: b

%FOO  bar baz # Should be ignored
              # with a warning.
---
"foo"

$doc1 = "foo"

Doc 1: "foo"

--- foo

--- "foo"

&a: key: &a value
foo:
  *a:

$doc1 = { foo => "key", key => "value" }

Doc 1: {
   "foo" : "key",
   "key" : "value"
}

---
foo: key
key: value

&a: key: &a value
foo: *a:

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

$doc1 = { "Ken Griff" => undef, "Mark McGwire" => undef, "Sammy Sosa" => undef }

Doc 1: {
   "Ken Griff" : null,
   "Mark McGwire" : null,
   "Sammy Sosa" : null
}

---
Ken Griff: null
Mark McGwire: null
Sammy Sosa: null

--- !!set
Mark McGwire:
Sammy Sosa:
Ken Griff:

---
- !!int 1
- !!int -2
- !!int 33

$doc1 = [1, -2, 33]

Doc 1: [
   1,
   -2,
   33
]

---
- 1
- -2
- 33

---
- !!int 1
- !!int -2
- !!int 33

--- !!map
? a
: b
--- !!seq
- !!str c
--- !!str
d
e

$doc1 = { a => "b" }
$doc2 = ["c"]
$doc3 = "d e"

Doc 1: {
   "a" : "b"
}

Doc 2: [
   "c"
]

Doc 3: "d e"

---
a: b
---
- c
--- d e

--- !!map
a: b
--- !!seq
- !!str c
--- !!str d e

---
plain: a
 b

 c

$doc1 = { plain => "a b\nc" }

Doc 1: {
   "plain" : "a b\nc"
}

---
plain: |-
  a b
  c

---
plain: |-
  a b
  c

- - s1_i1
  - s1_i2
- s2

$doc1 = [["s1_i1", "s1_i2"], "s2"]

Doc 1: [
   [
      "s1_i1",
      "s1_i2"
   ],
   "s2"
]

---
- - s1_i1
  - s1_i2
- s2

- - s1_i1
  - s1_i2
- s2

First occurrence: &anchor Foo
Second occurrence: *anchor
Override anchor: &anchor Bar
Reuse anchor: *anchor

$doc1 = {
  "First occurrence"  => "Foo",
  "Override anchor"   => "Bar",
  "Reuse anchor"      => "Bar",
  "Second occurrence" => "Foo",
}

Doc 1: {
   "First occurrence" : "Foo",
   "Override anchor" : "Bar",
   "Reuse anchor" : "Bar",
   "Second occurrence" : "Foo"
}

---
First occurrence: Foo
Override anchor: Bar
Reuse anchor: Bar
Second occurrence: Foo

First occurrence: &anchor Foo
Second occurrence: *anchor
Override anchor: &anchor Bar
Reuse anchor: *anchor

---
k:#foo
 &a !t s

$doc1 = "k:#foo &a !t s"

Doc 1: "k:#foo &a !t s"

--- k:#foo &a !t s

--- k:#foo &a !t s

&sequence
- a

$doc1 = ["a"]

Doc 1: [
   "a"
]

---
- a

&sequence
- a

"1 leading
    \ttab"

$doc1 = "1 leading \ttab"

Doc 1: "1 leading \ttab"

--- "1 leading \ttab"

"1 leading \ttab"

"2 leading
    \	tab"

$doc1 = "2 leading \ttab"

Doc 1: "2 leading \ttab"

--- "2 leading \ttab"

"2 leading \ttab"

"3 leading
    	tab"

$doc1 = "3 leading tab"

Doc 1: "3 leading tab"

--- 3 leading tab

"3 leading tab"

"4 leading
    \t  tab"

$doc1 = "4 leading \t  tab"

Doc 1: "4 leading \t  tab"

--- "4 leading \t  tab"

"4 leading \t  tab"

"5 leading
    \	  tab"

$doc1 = "5 leading \t  tab"

Doc 1: "5 leading \t  tab"

--- "5 leading \t  tab"

"5 leading \t  tab"

"6 leading
    	  tab"

$doc1 = "6 leading tab"

Doc 1: "6 leading tab"

--- 6 leading tab

"6 leading tab"

escaped slash: "a\/b"

$doc1 = { "escaped slash" => "a/b" }

Doc 1: {
   "escaped slash" : "a/b"
}

---
escaped slash: a/b

escaped slash: "a/b"

{
unquoted : "separate",
http://foo.com,
omitted value:,
}

$doc1 = {
  "http://foo.com" => undef,
  "omitted value"  => undef,
  "unquoted"       => "separate",
}

Doc 1: {
   "http://foo.com" : null,
   "omitted value" : null,
   "unquoted" : "separate"
}

---
http://foo.com: null
omitted value: null
unquoted: separate

{unquoted: "separate", http://foo.com: , omitted value: }

plain:
  This unquoted scalar
  spans many lines.

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

$doc1 = {
  plain  => "This unquoted scalar spans many lines.",
  quoted => "So does this quoted scalar.\n",
}

Doc 1: {
   "plain" : "This unquoted scalar spans many lines.",
   "quoted" : "So does this quoted scalar.\n"
}

---
plain: This unquoted scalar spans many lines.
quoted: |
  So does this quoted scalar.

plain: This unquoted scalar spans many lines.
quoted: "So does this quoted scalar.\n"

---
[
  [ a, [ [[b,c]]: d, e]]: 23
]

Line      : 3
Column    : 17
Expected  : EOL FLOWSEQ_END FLOW_COMMA WS
Got       : COLON
Where     : YAML/PP/Parser.pm line 392
YAML      : ": d, e]]: 23\n"
  at YAML/PP/Loader.pm line 94.

'here''s to "quotes"'

$doc1 = "here's to \"quotes\""

Doc 1: "here's to \"quotes\""

--- here's to "quotes"

'here''s to "quotes"'

{"foo"
: "bar"}

$doc1 = { foo => "bar" }

Doc 1: {
   "foo" : "bar"
}

---
foo: bar

{"foo": "bar"}

{"foo"
: bar}

$doc1 = { foo => "bar" }

Doc 1: {
   "foo" : "bar"
}

---
foo: bar

{"foo": bar}

{foo
: bar}

$doc1 = { foo => "bar" }

Doc 1: {
   "foo" : "bar"
}

---
foo: bar

{foo: bar}

--- >
 ab
 cd
 
 ef


 gh

$doc1 = "ab cd\nef\n\ngh\n"

Doc 1: "ab cd\nef\n\ngh\n"

--- |
  ab cd
  ef

  gh

--- >
  ab cd

  ef


  gh

- |
 detected
- >
 
  
  # detected
- |1
  explicit
- >
 detected

$doc1 = ["detected\n", "\n\n# detected\n", " explicit\n", "detected\n"]

Doc 1: [
   "detected\n",
   "\n\n# detected\n",
   " explicit\n",
   "detected\n"
]

---
- |
  detected
- |


  # detected
- |2
   explicit
- |
  detected

- |
  detected
- >


  # detected
- |2
   explicit
- >
  detected

  [1, 2, 3]  
  

$doc1 = [1, 2, 3]

Doc 1: [
   1,
   2,
   3
]

---
- 1
- 2
- 3

- 1
- 2
- 3

"foo: bar\": baz"

$doc1 = "foo: bar\": baz"

Doc 1: "foo: bar\": baz"

--- 'foo: bar": baz'

"foo: bar\": baz"

---
plain\value\with\backslashes

$doc1 = "plain\\value\\with\\backslashes"

Doc 1: "plain\\value\\with\\backslashes"

--- plain\value\with\backslashes

--- plain\value\with\backslashes

- aaa: |2
    xxx
  bbb: |
    xxx

$doc1 = [{ aaa => "xxx\n", bbb => "xxx\n" }]

Doc 1: [
   {
      "aaa" : "xxx\n",
      "bbb" : "xxx\n"
   }
]

---
- aaa: |
    xxx
  bbb: |
    xxx

- aaa: |
    xxx
  bbb: |
    xxx

plain: text
  lines
quoted: "text
  	lines"
block: |
  text
   	lines

$doc1 = {
  block  => "text\n \tlines\n",
  plain  => "text lines",
  quoted => "text lines",
}

Doc 1: {
   "block" : "text\n \tlines\n",
   "plain" : "text lines",
   "quoted" : "text lines"
}

---
block: "text\n \tlines\n"
plain: text lines
quoted: text lines

plain: text lines
quoted: "text lines"
block: |
  text
   	lines

---
! a

$doc1 = "a"

Doc 1: "a"

--- a

--- ! a

{foo: you, bar: far}

$doc1 = { bar => "far", foo => "you" }

Doc 1: {
   "bar" : "far",
   "foo" : "you"
}

---
bar: far
foo: you

{foo: you, bar: far}

canonical: !!binary "\
 R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5\
 OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+\
 +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC\
 AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs="
generic: !!binary |
 R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
 OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
 +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
 AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
description:
 The binary value above is a tiny arrow encoded as a gif image.

$doc1 = {
  canonical   => "R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLCAgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=",
  description => "The binary value above is a tiny arrow encoded as a gif image.",
  generic     => "R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5\nOTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+\n+f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC\nAgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=\n",
}

Doc 1: {
   "canonical" : "R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLCAgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=",
   "description" : "The binary value above is a tiny arrow encoded as a gif image.",
   "generic" : "R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5\nOTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+\n+f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC\nAgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=\n"
}

---
canonical: R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLCAgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
description: The binary value above is a tiny arrow encoded as a gif image.
generic: |
  R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
  OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
  +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
  AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=

canonical: !!binary "R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLCAgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs="
generic: !!binary |
  R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
  OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
  +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
  AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
description: The binary value above is a tiny arrow encoded as a gif image.

sequence: !!seq
- entry
- !!seq
 - nested
mapping: !!map
 foo: bar

$doc1 = { mapping => { foo => "bar" }, sequence => ["entry", ["nested"]] }

Doc 1: {
   "mapping" : {
      "foo" : "bar"
   },
   "sequence" : [
      "entry",
      [
         "nested"
      ]
   ]
}

---
mapping:
  foo: bar
sequence:
- entry
- - nested

sequence: !!seq
- entry
- !!seq
  - nested
mapping: !!map
  foo: bar

{x: :x}

$doc1 = { x => ":x" }

Doc 1: {
   "x" : ":x"
}

---
x: :x

{x: :x}

literal: |
  some
  text
folded: >
  some
  text

$doc1 = { folded => "some text\n", literal => "some\ntext\n" }

Doc 1: {
   "folded" : "some text\n",
   "literal" : "some\ntext\n"
}

---
folded: |
  some text
literal: |
  some
  text

literal: |
  some
  text
folded: >
  some text

- { one : two , three: four , }
- {five: six,seven : eight}

$doc1 = [
  { one => "two", three => "four" },
  { five => "six", seven => "eight" },
]

Doc 1: [
   {
      "one" : "two",
      "three" : "four"
   },
   {
      "five" : "six",
      "seven" : "eight"
   }
]

---
- one: two
  three: four
- five: six
  seven: eight

- {one: two, three: four}
- {five: six, seven: eight}

Folding:
  "Empty line
   	
  as a line feed"
Chomping: |
  Clipped empty lines
 

$doc1 = {
  Chomping => "Clipped empty lines\n",
  Folding  => "Empty line\nas a line feed",
}

Doc 1: {
   "Chomping" : "Clipped empty lines\n",
   "Folding" : "Empty line\nas a line feed"
}

---
Chomping: |
  Clipped empty lines
Folding: |-
  Empty line
  as a line feed

Folding: "Empty line\nas a line feed"
Chomping: |
  Clipped empty lines

- [ one, two, ]
- [three ,four]

$doc1 = [["one", "two"], ["three", "four"]]

Doc 1: [
   [
      "one",
      "two"
   ],
   [
      "three",
      "four"
   ]
]

---
- - one
  - two
- - three
  - four

- - one
  - two
- - three
  - four

---
{ "foo"
  :bar }

$doc1 = { foo => "bar" }

Doc 1: {
   "foo" : "bar"
}

---
foo: bar

--- {"foo": bar}

key:    # Comment
  value

$doc1 = { key => "value" }

Doc 1: {
   "key" : "value"
}

---
key: value

key: value

- { "key":value }
- { "key"::value }

$doc1 = [{ key => "value" }, { key => ":value" }]

Doc 1: [
   {
      "key" : "value"
   },
   {
      "key" : ":value"
   }
]

---
- key: value
- key: :value

- {"key": value}
- {"key": :value}

%TAG !m! !my-
--- # Bulb here
!m!light fluorescent
...
%TAG !m! !my-
--- # Color here
!m!light green

$doc1 = "fluorescent"
$doc2 = "green"

Doc 1: "fluorescent"

Doc 2: "green"

--- fluorescent
--- green

--- !my-light fluorescent
...
--- !my-light green

? explicit key # Empty value
? |
  block key
: - one # Explicit compact
  - two # block value

$doc1 = { "block key\n" => ["one", "two"], "explicit key" => undef }

Doc 1: {
   "block key\n" : [
      "one",
      "two"
   ],
   "explicit key" : null
}

---
? |
  block key
: - one
  - two
explicit key: null

explicit key:
? |
  block key
: - one
  - two

{ ?foo: bar,
bar: 42
}

$doc1 = { "?foo" => "bar", "bar" => 42 }

Doc 1: {
   "?foo" : "bar",
   "bar" : 42
}

---
?foo: bar
bar: 42

{?foo: bar, bar: 42}

- foo

$doc1 = ["foo"]

Doc 1: [
   "foo"
]

---
- foo

- foo

- foo:	 bar
- - baz
  -	baz

$doc1 = [{ foo => "bar" }, ["baz", "baz"]]

Doc 1: [
   {
      "foo" : "bar"
   },
   [
      "baz",
      "baz"
   ]
]

---
- foo: bar
- - baz
  - baz

- foo: bar
- - baz
  - baz

---
&mapping
&key [ &item a, b, c ]: value

Line      : 3
Column    : 16
Message   : A node can only have one anchor
Where     : YAML/PP/Parser.pm line 704
YAML      : " b, c ]: value\n"
  at YAML/PP/Loader.pm line 94.

	[
	]

$doc1 = []

Doc 1: []

--- []

[]

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

$doc1 = ["foo", "bar", "baz"]

Doc 1: [
   "foo",
   "bar",
   "baz"
]

---
- foo
- bar
- baz

---
- !local foo
- !!str bar
- !<tag:example.com,2000:app/tag!> baz

--- |+
 ab
 
  
...

$doc1 = "ab\n\n \n"

Doc 1: "ab\n\n \n"

--- |
  ab

   

--- |
  ab

   
...

'foo: bar\': baz'

$doc1 = { "foo: bar\\" => "baz'" }

Doc 1: {
   "foo: bar\\" : "baz'"
}

---
'foo: bar\': baz'

'foo: bar\': baz'

  # 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.

$doc1 = {
  "Not indented" => {
    "By one space" => "By four\n  spaces\n",
    "Flow style"   => ["By two", "Also by two", "Still by two"],
  },
}

Doc 1: {
   "Not indented" : {
      "By one space" : "By four\n  spaces\n",
      "Flow style" : [
         "By two",
         "Also by two",
         "Still by two"
      ]
   }
}

---
Not indented:
  By one space: |
    By four
      spaces
  Flow style:
  - By two
  - Also by two
  - Still by two

Not indented:
  By one space: |
    By four
      spaces
  Flow style:
  - By two
  - Also by two
  - Still by two

# ASCII Art
--- |
  \//||\/||
  // ||  ||__

$doc1 = "\\//||\\/||\n// ||  ||__\n"

Doc 1: "\\//||\\/||\n// ||  ||__\n"

--- |
  \//||\/||
  // ||  ||__

--- |
  \//||\/||
  // ||  ||__

foo: !!seq
  - !!str a
  - !!map
    key: !!str value

$doc1 = { foo => ["a", { key => "value" }] }

Doc 1: {
   "foo" : [
      "a",
      {
         "key" : "value"
      }
   ]
}

---
foo:
- a
- key: value

foo: !!seq
- !!str a
- !!map
  key: !!str value

---
a: &anchor
b: *anchor

$doc1 = { a => undef, b => undef }

Doc 1: {
   "a" : null,
   "b" : null
}

---
a: null
b: null

---
a: &anchor
b: *anchor

%FOO  bar baz # Should be ignored
              # with a warning.
--- "foo"

$doc1 = "foo"

Doc 1: "foo"

--- foo

--- "foo"

? &a a
: &b b
: *a

$doc1 = { "" => "a", "a" => "b" }

Doc 1: {
   "" : "a",
   "a" : "b"
}

---
'': a
a: b

&a a: &b b
: *a

---
?
- a
- b
:
- c
- d

$doc1 = { "['a','b']" => ["c", "d"] }

Doc 1: {
   "['a','b']" : [
      "c",
      "d"
   ]
}

---
"['a','b']":
- c
- d

---
? - a
  - b
: - c
  - d

"foo\nbar:baz\tx \\$%^&*()x": 23
'x\ny:z\tx $%^&*()x': 24

$doc1 = { "foo\nbar:baz\tx \\\$%^&*()x" => 23, "x\\ny:z\\tx \$%^&*()x" => 24 }

Doc 1: {
   "foo\nbar:baz\tx \\$%^&*()x" : 23,
   "x\\ny:z\\tx $%^&*()x" : 24
}

---
"foo\nbar:baz\tx \\$%^&*()x": 23
x\ny:z\tx $%^&*()x: 24

"foo\nbar:baz\tx \\$%^&*()x": 23
'x\ny:z\tx $%^&*()x': 24

>
 Sammy Sosa completed another
 fine season with great stats.

   63 Home Runs
   0.288 Batting Average

 What a year!

$doc1 = "Sammy Sosa completed another fine season with great stats.\n\n  63 Home Runs\n  0.288 Batting Average\n\nWhat a year!\n"

Doc 1: "Sammy Sosa completed another fine season with great stats.\n\n  63 Home Runs\n  0.288 Batting Average\n\nWhat a year!\n"

--- |
  Sammy Sosa completed another fine season with great stats.

    63 Home Runs
    0.288 Batting Average

  What a year!

>
  Sammy Sosa completed another fine season with great stats.


    63 Home Runs

    0.288 Batting Average


  What a year!

# Private
---
!foo "bar"
...
# Global
%TAG ! tag:example.com,2000:app/
---
!foo "bar"

$doc1 = "bar"
$doc2 = "bar"

Doc 1: "bar"

Doc 2: "bar"

--- bar
--- bar

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

---
"
  foo 
 
    bar

  baz
"

$doc1 = " foo\nbar\nbaz "

Doc 1: " foo\nbar\nbaz "

--- |2-
   foo
  bar
  baz 

--- " foo\nbar\nbaz "

---
---

$doc1 = undef
$doc2 = undef

Doc 1: null

Doc 2: null

--- null
--- null

---
---

Document
---
# Empty
...
%YAML 1.2
---
matches %: 20

$doc1 = "Document"
$doc2 = undef
$doc3 = { "matches %" => 20 }

Doc 1: "Document"

Doc 2: null

Doc 3: {
   "matches %" : 20
}

--- Document
--- null
---
matches %: 20

Document
---
...
%YAML 1.2
---
matches %: 20

-
  "flow in block"
- >
 Block scalar
- !!map # Block collection
  foo : bar

$doc1 = ["flow in block", "Block scalar\n", { foo => "bar" }]

Doc 1: [
   "flow in block",
   "Block scalar\n",
   {
      "foo" : "bar"
   }
]

---
- flow in block
- |
  Block scalar
- foo: bar

- "flow in block"
- >
  Block scalar
- !!map
  foo: bar

!!str a: b
c: !!int 42
e: !!str f
g: h
!!str 23: !!bool false

$doc1 = {
  23 => bless(do{\(my $o = 0)}, "JSON::PP::Boolean"),
  a  => "b",
  c  => 42,
  e  => "f",
  g  => "h",
}

Doc 1: {
   "23" : false,
   "a" : "b",
   "c" : 42,
   "e" : "f",
   "g" : "h"
}

---
'23': false
a: b
c: 42
e: f
g: h

!!str a: b
c: !!int 42
e: !!str f
g: h
!!str 23: !!bool false

--- |-
 ab
 
 
...

$doc1 = "ab"

Doc 1: "ab"

--- ab

--- |-
  ab
...

" 1st non-empty

 2nd non-empty 
	3rd non-empty "

$doc1 = " 1st non-empty\n2nd non-empty 3rd non-empty "

Doc 1: " 1st non-empty\n2nd non-empty 3rd non-empty "

--- |2-
   1st non-empty
  2nd non-empty 3rd non-empty 

" 1st non-empty\n2nd non-empty 3rd non-empty "

---
top1: &node1
  &k1 key1: one
top2: &node2 # comment
  key2: two
top3:
  &k3 key3: three
top4: &node4
  &k4 key4: four
top5: &node5
  key5: five
top6: &val6
  six
top7:
  &val7 seven

$doc1 = {
  top1 => { key1 => "one" },
  top2 => { key2 => "two" },
  top3 => { key3 => "three" },
  top4 => { key4 => "four" },
  top5 => { key5 => "five" },
  top6 => "six",
  top7 => "seven",
}

Doc 1: {
   "top1" : {
      "key1" : "one"
   },
   "top2" : {
      "key2" : "two"
   },
   "top3" : {
      "key3" : "three"
   },
   "top4" : {
      "key4" : "four"
   },
   "top5" : {
      "key5" : "five"
   },
   "top6" : "six",
   "top7" : "seven"
}

---
top1:
  key1: one
top2:
  key2: two
top3:
  key3: three
top4:
  key4: four
top5:
  key5: five
top6: six
top7: seven

---
top1: &node1
  &k1 key1: one
top2: &node2
  key2: two
top3:
  &k3 key3: three
top4: &node4
  &k4 key4: four
top5: &node5
  key5: five
top6: &val6 six
top7: &val7 seven

---
hr:
  - Mark McGwire
  # Following node labeled SS
  - &SS Sammy Sosa
rbi:
  - *SS # Subsequent occurrence
  - Ken Griffey

$doc1 = {
  hr  => ["Mark McGwire", "Sammy Sosa"],
  rbi => ["Sammy Sosa", "Ken Griffey"],
}

Doc 1: {
   "hr" : [
      "Mark McGwire",
      "Sammy Sosa"
   ],
   "rbi" : [
      "Sammy Sosa",
      "Ken Griffey"
   ]
}

---
hr:
- Mark McGwire
- Sammy Sosa
rbi:
- Sammy Sosa
- Ken Griffey

---
hr:
- Mark McGwire
- &SS Sammy Sosa
rbi:
- *SS
- Ken Griffey

!<tag:yaml.org,2002:str> foo :
  !<!bar> baz

$doc1 = { foo => "baz" }

Doc 1: {
   "foo" : "baz"
}

---
foo: baz

!!str foo: !bar baz

>

 folded
 line

 next
 line
   * bullet

   * list
   * lines

 last
 line

# Comment

$doc1 = "\nfolded line\nnext line\n  * bullet\n\n  * list\n  * lines\n\nlast line\n"

Doc 1: "\nfolded line\nnext line\n  * bullet\n\n  * list\n  * lines\n\nlast line\n"

--- |

  folded line
  next line
    * bullet

    * list
    * lines

  last line

>

  folded line

  next line

    * bullet


    * list

    * lines


  last line

---
[ word1
# comment
, word2]

$doc1 = ["word1", "word2"]

Doc 1: [
   "word1",
   "word2"
]

---
- word1
- word2

---
- word1
- word2

? a
? b
c:

$doc1 = { a => undef, b => undef, c => undef }

Doc 1: {
   "a" : null,
   "b" : null,
   "c" : null
}

---
a: null
b: null
c: null

a:
b:
c:

---
scalar1
...
key: value

$doc1 = "scalar1"
$doc2 = { key => "value" }

Doc 1: "scalar1"

Doc 2: {
   "key" : "value"
}

--- scalar1
---
key: value

--- scalar1
...
key: value

---
nested sequences:
- - - []
- - - {}
key1: []
key2: {}

$doc1 = { "key1" => [], "key2" => {}, "nested sequences" => [[[[]]], [[{}]]] }

Doc 1: {
   "key1" : [],
   "key2" : {},
   "nested sequences" : [
      [
         [
            []
         ]
      ],
      [
         [
            {}
         ]
      ]
   ]
}

---
key1: []
key2: {}
nested sequences:
- - - []
- - - {}

---
nested sequences:
- - - []
- - - {}
key1: []
key2: {}

---word1
word2

$doc1 = "---word1 word2"

Doc 1: "---word1 word2"

--- '---word1 word2'

'---word1 word2'

'implicit block key' : [
  'implicit flow key' : value,
 ]

$doc1 = { "implicit block key" => [{ "implicit flow key" => "value" }] }

Doc 1: {
   "implicit block key" : [
      {
         "implicit flow key" : "value"
      }
   ]
}

---
implicit block key:
- implicit flow key: value

'implicit block key':
- {'implicit flow key': value}

---
key ends with two colons::: value

Line      : 2
Column    : 25
Message   : Invalid plain scalar
Where     : YAML/PP/Lexer.pm line 378
YAML      : "::: value"
  at YAML/PP/Loader.pm line 94.

  # Comment
   

---
- { single line, a: b}
- { multi
  line, a: b}

$doc1 = [
  { "a" => "b", "single line" => undef },
  { "a" => "b", "multi line" => undef },
]

Doc 1: [
   {
      "a" : "b",
      "single line" : null
   },
   {
      "a" : "b",
      "multi line" : null
   }
]

---
- a: b
  single line: null
- a: b
  multi line: null

---
- {single line: , a: b}
- {multi line: , a: b}

! a

$doc1 = "a"

Doc 1: "a"

--- a

! a

key:
 - item1
 - item2

$doc1 = { key => ["item1", "item2"] }

Doc 1: {
   "key" : [
      "item1",
      "item2"
   ]
}

---
key:
- item1
- item2

key:
- item1
- item2

[
"double
 quoted", 'single
           quoted',
plain
 text, [ nested ],
single: pair,
]

$doc1 = [
  "double quoted",
  "single quoted",
  "plain text",
  ["nested"],
  { single => "pair" },
]

Doc 1: [
   "double quoted",
   "single quoted",
   "plain text",
   [
      "nested"
   ],
   {
      "single" : "pair"
   }
]

---
- double quoted
- single quoted
- plain text
- - nested
- single: pair

- "double quoted"
- 'single quoted'
- plain text
- - nested
- {single: pair}

---
- &😁 unicode anchor

$doc1 = ["unicode anchor"]

Doc 1: [
   "unicode anchor"
]

---
- unicode anchor

---
- &😁 unicode anchor

 - key: value
   key2: value2
 -
   key3: value3

$doc1 = [{ key => "value", key2 => "value2" }, { key3 => "value3" }]

Doc 1: [
   {
      "key" : "value",
      "key2" : "value2"
   },
   {
      "key3" : "value3"
   }
]

---
- key: value
  key2: value2
- key3: value3

- key: value
  key2: value2
- key3: value3

--- >-
  trimmed
  
 

  as
  space

$doc1 = "trimmed\n\n\nas space"

Doc 1: "trimmed\n\n\nas space"

--- |-
  trimmed


  as space

--- >-
  trimmed



  as space

--- >
  Mark McGwire's
  year was crippled
  by a knee injury.

$doc1 = "Mark McGwire's year was crippled by a knee injury.\n"

Doc 1: "Mark McGwire's year was crippled by a knee injury.\n"

--- |
  Mark McGwire's year was crippled by a knee injury.

--- >
  Mark McGwire's year was crippled by a knee injury.

foo: |-
 	bar

$doc1 = { foo => "\tbar" }

Doc 1: {
   "foo" : "\tbar"
}

---
foo: "\tbar"

foo: |-
  	bar

foo: |-
 	bar

$doc1 = { foo => "\tbar" }

Doc 1: {
   "foo" : "\tbar"
}

---
foo: "\tbar"

foo: |-
  	bar

# Comment only.

---
- { "single line", a: b}
- { "multi
  line", a: b}

$doc1 = [
  { "a" => "b", "single line" => undef },
  { "a" => "b", "multi line" => undef },
]

Doc 1: [
   {
      "a" : "b",
      "single line" : null
   },
   {
      "a" : "b",
      "multi line" : null
   }
]

---
- a: b
  single line: null
- a: b
  multi line: null

---
- {"single line": , a: b}
- {"multi line": , a: b}

Mapping: Document
---
# Empty
...
%YAML 1.2
---
matches %: 20

$doc1 = { Mapping => "Document" }
$doc2 = undef
$doc3 = { "matches %" => 20 }

Doc 1: {
   "Mapping" : "Document"
}

Doc 2: null

Doc 3: {
   "matches %" : 20
}

---
Mapping: Document
--- null
---
matches %: 20

Mapping: Document
---
...
%YAML 1.2
---
matches %: 20

a:
  b:
    c: d
  e:
    f: g
h: i

$doc1 = { a => { b => { c => "d" }, e => { f => "g" } }, h => "i" }

Doc 1: {
   "a" : {
      "b" : {
         "c" : "d"
      },
      "e" : {
         "f" : "g"
      }
   },
   "h" : "i"
}

---
a:
  b:
    c: d
  e:
    f: g
h: i

a:
  b:
    c: d
  e:
    f: g
h: i

foo:
  bar: baz

$doc1 = { foo => { bar => "baz" } }

Doc 1: {
   "foo" : {
      "bar" : "baz"
   }
}

---
foo:
  bar: baz

foo:
  bar: baz

---
&a1
!!str
scalar1
---
!!str
&a2
scalar2
---
&a3
!!str scalar3
---
&a4 !!map
&a5 !!str key5: value4
---
a6: 1
&anchor6 b6: 2
---
!!map
&a8 !!str key8: value7
---
!!map
!!str &a10 key10: value9
---
!!str &a11
value11

$doc1 = "scalar1"
$doc2 = "scalar2"
$doc3 = "scalar3"
$doc4 = { key5 => "value4" }
$doc5 = { a6 => 1, b6 => 2 }
$doc6 = { key8 => "value7" }
$doc7 = { key10 => "value9" }
$doc8 = "value11"

Doc 1: "scalar1"

Doc 2: "scalar2"

Doc 3: "scalar3"

Doc 4: {
   "key5" : "value4"
}

Doc 5: {
   "a6" : 1,
   "b6" : 2
}

Doc 6: {
   "key8" : "value7"
}

Doc 7: {
   "key10" : "value9"
}

Doc 8: "value11"

--- scalar1
--- scalar2
--- scalar3
---
key5: value4
---
a6: 1
b6: 2
---
key8: value7
---
key10: value9
--- value11

--- &a1 !!str scalar1
--- &a2 !!str scalar2
--- &a3 !!str scalar3
--- &a4 !!map
&a5 !!str key5: value4
---
a6: 1
&anchor6 b6: 2
--- !!map
&a8 !!str key8: value7
--- !!map
&a10 !!str key10: value9
--- &a11 !!str value11

- [ YAML : separate ]
- [ "JSON like":adjacent ]
- [ {JSON: like}:adjacent ]

Line      : 3
Column    : 17
Expected  : EOL FLOWSEQ_END FLOW_COMMA WS
Got       : PLAIN
Where     : YAML/PP/Parser.pm line 392
YAML      : ":adjacent ]"
  at YAML/PP/Loader.pm line 94.

--- "a
...x
b"

$doc1 = "a ...x b"

Doc 1: "a ...x b"

--- a ...x b

--- "a ...x b"

---
- { "single line": value}
- { "multi
  line": value}

$doc1 = [{ "single line" => "value" }, { "multi line" => "value" }]

Doc 1: [
   {
      "single line" : "value"
   },
   {
      "multi line" : "value"
   }
]

---
- single line: value
- multi line: value

---
- {"single line": value}
- {"multi line": value}

single: 'text'
double: "text"

$doc1 = { double => "text", single => "text" }

Doc 1: {
   "double" : "text",
   "single" : "text"
}

---
double: text
single: text

single: 'text'
double: "text"

---
" 1st non-empty

 2nd non-empty 
 3rd non-empty "

$doc1 = " 1st non-empty\n2nd non-empty 3rd non-empty "

Doc 1: " 1st non-empty\n2nd non-empty 3rd non-empty "

--- |2-
   1st non-empty
  2nd non-empty 3rd non-empty 

--- " 1st non-empty\n2nd non-empty 3rd non-empty "

---
# Products purchased
- item    : Super Hoop
  quantity: 1
- item    : Basketball
  quantity: 4
- item    : Big Shoes
  quantity: 1

$doc1 = [
  { item => "Super Hoop", quantity => 1 },
  { item => "Basketball", quantity => 4 },
  { item => "Big Shoes", quantity => 1 },
]

Doc 1: [
   {
      "item" : "Super Hoop",
      "quantity" : 1
   },
   {
      "item" : "Basketball",
      "quantity" : 4
   },
   {
      "item" : "Big Shoes",
      "quantity" : 1
   }
]

---
- item: Super Hoop
  quantity: 1
- item: Basketball
  quantity: 4
- item: Big Shoes
  quantity: 1

---
- item: Super Hoop
  quantity: 1
- item: Basketball
  quantity: 4
- item: Big Shoes
  quantity: 1

# Private
!foo "bar"
...
# Global
%TAG ! tag:example.com,2000:app/
---
!foo "bar"

$doc1 = "bar"
$doc2 = "bar"

Doc 1: "bar"

Doc 2: "bar"

--- bar
--- bar

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

a
b  
  c
d

e

$doc1 = "a b c d\ne"

Doc 1: "a b c d\ne"

--- |-
  a b c d
  e

|-
  a b c d
  e

? a
: -	b
  -  -	c
     - d

$doc1 = { a => ["b", ["c", "d"]] }

Doc 1: {
   "a" : [
      "b",
      [
         "c",
         "d"
      ]
   ]
}

---
a:
- b
- - c
  - d

a:
- b
- - c
  - d

strip: |-
  text
clip: |
  text
keep: |+
  text

$doc1 = { clip => "text\n", keep => "text\n", strip => "text" }

Doc 1: {
   "clip" : "text\n",
   "keep" : "text\n",
   "strip" : "text"
}

---
clip: |
  text
keep: |
  text
strip: text

strip: |-
  text
clip: |
  text
keep: |
  text