diff --git a/YamlDotNet.Test/Serialization/SerializationTestHelper.cs b/YamlDotNet.Test/Serialization/SerializationTestHelper.cs
index 6fffead17..a5e17857b 100644
--- a/YamlDotNet.Test/Serialization/SerializationTestHelper.cs
+++ b/YamlDotNet.Test/Serialization/SerializationTestHelper.cs
@@ -127,9 +127,9 @@ protected TextReader UsingReaderFor(string text)
             return new StringReader(text);
         }
 
-        protected static EventReader EventReaderFor(string yaml)
+        protected static IParser ParserFor(string yaml)
         {
-            return new EventReader(new Parser(new StringReader(yaml)));
+            return new Parser(new StringReader(yaml));
         }
 
         protected string Lines(params string[] lines)
diff --git a/YamlDotNet.Test/Serialization/SerializationTests.cs b/YamlDotNet.Test/Serialization/SerializationTests.cs
index 05dcc9169..c52937e75 100644
--- a/YamlDotNet.Test/Serialization/SerializationTests.cs
+++ b/YamlDotNet.Test/Serialization/SerializationTests.cs
@@ -595,7 +595,7 @@ public void DeserializeListOfDictionaries()
         [Fact]
         public void DeserializeTwoDocuments()
         {
-            var reader = EventReaderFor(Lines(
+            var reader = ParserFor(Lines(
                 "---",
                 "aaa: 111",
                 "---",
@@ -613,7 +613,7 @@ public void DeserializeTwoDocuments()
         [Fact]
         public void DeserializeThreeDocuments()
         {
-            var reader = EventReaderFor(Lines(
+            var reader = ParserFor(Lines(
                 "---",
                 "aaa: 111",
                 "---",
@@ -963,7 +963,7 @@ public void BackreferencesAreMergedWithMappings()
             var stream = Yaml.StreamFrom("backreference.yaml");
 
             var parser = new MergingParser(new Parser(stream));
-            var result = Deserializer.Deserialize<Dictionary<string, Dictionary<string, string>>>(new EventReader(parser));
+            var result = Deserializer.Deserialize<Dictionary<string, Dictionary<string, string>>>(parser);
 
             var alias = result["alias"];
             alias.Should()
@@ -986,7 +986,7 @@ public void MergingDoesNotProduceDuplicateAnchors()
                 useMyValue:
                   key: *myValue
             "));
-            var result = Deserializer.Deserialize<Dictionary<string, Dictionary<string, string>>>(new EventReader(parser));
+            var result = Deserializer.Deserialize<Dictionary<string, Dictionary<string, string>>>(parser);
 
             var alias = result["alias"];
             alias.Should()
@@ -1037,7 +1037,7 @@ public void ExampleFromSpecificationIsHandledCorrectly()
                     label: center/big
             "));
 
-            var result = Deserializer.Deserialize<Dictionary<string, List<Dictionary<string, string>>>>(new EventReader(parser));
+            var result = Deserializer.Deserialize<Dictionary<string, List<Dictionary<string, string>>>>(parser);
 
             int index = 0;
             foreach (var mapping in result["results"])
diff --git a/YamlDotNet/Core/IParser.cs b/YamlDotNet/Core/IParser.cs
index fd1afffc3..93c8b18a9 100644
--- a/YamlDotNet/Core/IParser.cs
+++ b/YamlDotNet/Core/IParser.cs
@@ -1,16 +1,16 @@
 //  This file is part of YamlDotNet - A .NET library for YAML.
 //  Copyright (c) Antoine Aubry and contributors
-    
+
 //  Permission is hereby granted, free of charge, to any person obtaining a copy of
 //  this software and associated documentation files (the "Software"), to deal in
 //  the Software without restriction, including without limitation the rights to
 //  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
 //  of the Software, and to permit persons to whom the Software is furnished to do
 //  so, subject to the following conditions:
-    
+
 //  The above copyright notice and this permission notice shall be included in all
 //  copies or substantial portions of the Software.
-    
+
 //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -19,7 +19,7 @@
 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 //  SOFTWARE.
 
-using YamlDotNet.Core.Events;
+using YamlDotNet.Core.Events;
 
 namespace YamlDotNet.Core
 {
@@ -29,7 +29,8 @@ namespace YamlDotNet.Core
     public interface IParser
     {
         /// <summary>
-        /// Gets the current event.
+        /// Gets the current event. Returns null before the first call to <see cref="MoveNext" />,
+        /// and also after <see cref="MoveNext" /> returns false.
         /// </summary>
         ParsingEvent Current { get; }
 
diff --git a/YamlDotNet/Core/EventReader.cs b/YamlDotNet/Core/ParserExtensions.cs
similarity index 67%
rename from YamlDotNet/Core/EventReader.cs
rename to YamlDotNet/Core/ParserExtensions.cs
index e1626fbf3..ffff4e92a 100644
--- a/YamlDotNet/Core/EventReader.cs
+++ b/YamlDotNet/Core/ParserExtensions.cs
@@ -1,16 +1,16 @@
 //  This file is part of YamlDotNet - A .NET library for YAML.
 //  Copyright (c) Antoine Aubry and contributors
-    
+
 //  Permission is hereby granted, free of charge, to any person obtaining a copy of
 //  this software and associated documentation files (the "Software"), to deal in
 //  the Software without restriction, including without limitation the rights to
 //  use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
 //  of the Software, and to permit persons to whom the Software is furnished to do
 //  so, subject to the following conditions:
-    
+
 //  The above copyright notice and this permission notice shall be included in all
 //  copies or substantial portions of the Software.
-    
+
 //  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 //  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 //  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -19,51 +19,26 @@
 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 //  SOFTWARE.
 
-using System.IO;
 using System.Globalization;
+using System.IO;
 using YamlDotNet.Core.Events;
 
 namespace YamlDotNet.Core
 {
     /// <summary>
-    /// Reads events from a sequence of <see cref="ParsingEvent" />.
+    /// Extension methods that provide useful abstractions over <see cref="IParser"/>.
     /// </summary>
-    public class EventReader
+    public static class ParserExtensions
     {
-        private readonly IParser parser;
-        private bool endOfStream;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="EventReader"/> class.
-        /// </summary>
-        /// <param name="parser">The parser that provides the events.</param>
-        public EventReader(IParser parser)
-        {
-            this.parser = parser;
-            MoveNext();
-        }
-
-        /// <summary>
-        /// Gets the underlying parser.
-        /// </summary>
-        /// <value>The parser.</value>
-        public IParser Parser
-        {
-            get
-            {
-                return parser;
-            }
-        }
-
         /// <summary>
         /// Ensures that the current event is of the specified type, returns it and moves to the next event.
         /// </summary>
         /// <typeparam name="T">Type of the <see cref="ParsingEvent"/>.</typeparam>
         /// <returns>Returns the current event.</returns>
         /// <exception cref="YamlException">If the current event is not of the specified type.</exception>
-        public T Expect<T>() where T : ParsingEvent
+        public static T Expect<T>(this IParser parser) where T : ParsingEvent
         {
-            var expectedEvent = Allow<T>();
+            var expectedEvent = parser.Allow<T>();
             if (expectedEvent == null)
             {
                 // TODO: Throw a better exception
@@ -79,18 +54,16 @@ public T Expect<T>() where T : ParsingEvent
         /// </summary>
         /// <typeparam name="T">Type of the event.</typeparam>
         /// <returns>Returns true if the current event is of type <typeparamref name="T"/>. Otherwise returns false.</returns>
-        public bool Accept<T>() where T : ParsingEvent
+        public static bool Accept<T>(this IParser parser) where T : ParsingEvent
         {
-            ThrowIfAtEndOfStream();
-            return parser.Current is T;
-        }
-
-        private void ThrowIfAtEndOfStream()
-        {
-            if (endOfStream)
+            if(parser.Current == null)
             {
-                throw new EndOfStreamException();
+                if (!parser.MoveNext())
+                {
+                    throw new EndOfStreamException();
+                }
             }
+            return parser.Current is T;
         }
 
         /// <summary>
@@ -100,14 +73,14 @@ private void ThrowIfAtEndOfStream()
         /// </summary>
         /// <typeparam name="T">Type of the <see cref="ParsingEvent"/>.</typeparam>
         /// <returns>Returns the current event if it is of type T; otherwise returns null.</returns>
-        public T Allow<T>() where T : ParsingEvent
+        public static T Allow<T>(this IParser parser) where T : ParsingEvent
         {
-            if (!Accept<T>())
+            if (!parser.Accept<T>())
             {
                 return null;
             }
-            var @event = (T) parser.Current;
-            MoveNext();
+            var @event = (T)parser.Current;
+            parser.MoveNext();
             return @event;
         }
 
@@ -116,32 +89,27 @@ public T Allow<T>() where T : ParsingEvent
         /// </summary>
         /// <typeparam name="T">Type of the <see cref="ParsingEvent"/>.</typeparam>
         /// <returns>Returns the current event if it is of type T; otherwise returns null.</returns>
-        public T Peek<T>() where T : ParsingEvent
+        public static T Peek<T>(this IParser parser) where T : ParsingEvent
         {
-            if (!Accept<T>())
+            if (!parser.Accept<T>())
             {
                 return null;
             }
-            return (T) parser.Current;
+            return (T)parser.Current;
         }
 
         /// <summary>
         /// Skips the current event and any nested event.
         /// </summary>
-        public void SkipThisAndNestedEvents()
+        public static void SkipThisAndNestedEvents(this IParser parser)
         {
             var depth = 0;
             do
             {
-                depth += Peek<ParsingEvent>().NestingIncrease;
-                MoveNext();
+                depth += parser.Peek<ParsingEvent>().NestingIncrease;
+                parser.MoveNext();
             }
-            while(depth > 0);
-        }
-
-        private void MoveNext()
-        {
-            endOfStream = !parser.MoveNext();
+            while (depth > 0);
         }
     }
 }
\ No newline at end of file
diff --git a/YamlDotNet/RepresentationModel/YamlDocument.cs b/YamlDotNet/RepresentationModel/YamlDocument.cs
index cac4fd99f..fb65ebfce 100644
--- a/YamlDotNet/RepresentationModel/YamlDocument.cs
+++ b/YamlDotNet/RepresentationModel/YamlDocument.cs
@@ -59,17 +59,16 @@ public YamlDocument(string rootNode)
         /// <summary>
         /// Initializes a new instance of the <see cref="YamlDocument"/> class.
         /// </summary>
-        /// <param name="events">The events.</param>
-        internal YamlDocument(EventReader events)
+        internal YamlDocument(IParser parser)
         {
             DocumentLoadingState state = new DocumentLoadingState();
 
-            events.Expect<DocumentStart>();
+            parser.Expect<DocumentStart>();
 
-            while (!events.Accept<DocumentEnd>())
+            while (!parser.Accept<DocumentEnd>())
             {
                 Debug.Assert(RootNode == null);
-                RootNode = YamlNode.ParseNode(events, state);
+                RootNode = YamlNode.ParseNode(parser, state);
 
                 if (RootNode is YamlAliasNode)
                 {
@@ -89,7 +88,7 @@ internal YamlDocument(EventReader events)
             }
 #endif
 
-            events.Expect<DocumentEnd>();
+            parser.Expect<DocumentEnd>();
         }
 
         /// <summary>
diff --git a/YamlDotNet/RepresentationModel/YamlMappingNode.cs b/YamlDotNet/RepresentationModel/YamlMappingNode.cs
index 29171c3db..2f0e882af 100644
--- a/YamlDotNet/RepresentationModel/YamlMappingNode.cs
+++ b/YamlDotNet/RepresentationModel/YamlMappingNode.cs
@@ -59,24 +59,22 @@ public IDictionary<YamlNode, YamlNode> Children
         /// <summary>
         /// Initializes a new instance of the <see cref="YamlMappingNode"/> class.
         /// </summary>
-        /// <param name="events">The events.</param>
-        /// <param name="state">The state.</param>
-        internal YamlMappingNode(EventReader events, DocumentLoadingState state)
+        internal YamlMappingNode(IParser parser, DocumentLoadingState state)
         {
-            Load(events, state);
+            Load(parser, state);
         }
 
-        private void Load(EventReader events, DocumentLoadingState state)
+        private void Load(IParser parser, DocumentLoadingState state)
         {
-            MappingStart mapping = events.Expect<MappingStart>();
+            MappingStart mapping = parser.Expect<MappingStart>();
             base.Load(mapping, state);
             Style = mapping.Style;
 
             bool hasUnresolvedAliases = false;
-            while (!events.Accept<MappingEnd>())
+            while (!parser.Accept<MappingEnd>())
             {
-                YamlNode key = ParseNode(events, state);
-                YamlNode value = ParseNode(events, state);
+                YamlNode key = ParseNode(parser, state);
+                YamlNode value = ParseNode(parser, state);
 
                 try
                 {
@@ -111,7 +109,7 @@ private void Load(EventReader events, DocumentLoadingState state)
             }
 #endif
 
-            events.Expect<MappingEnd>();
+            parser.Expect<MappingEnd>();
         }
 
         /// <summary>
@@ -394,9 +392,9 @@ System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
 
         #endregion
 
-        void IYamlConvertible.Read(EventReader reader, Type expectedType, Func<EventReader, Type, object> nestedObjectDeserializer)
+        void IYamlConvertible.Read(IParser parser, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer)
         {
-            Load(reader, new DocumentLoadingState());
+            Load(parser, new DocumentLoadingState());
         }
 
         void IYamlConvertible.Write(IEmitter emitter)
diff --git a/YamlDotNet/RepresentationModel/YamlNode.cs b/YamlDotNet/RepresentationModel/YamlNode.cs
index dcf87b9b8..40e5b33e8 100644
--- a/YamlDotNet/RepresentationModel/YamlNode.cs
+++ b/YamlDotNet/RepresentationModel/YamlNode.cs
@@ -73,31 +73,29 @@ internal void Load(NodeEvent yamlEvent, DocumentLoadingState state)
         }
 
         /// <summary>
-        /// Parses the node represented by the next event in <paramref name="events" />.
+        /// Parses the node represented by the next event in <paramref name="parser" />.
         /// </summary>
-        /// <param name="events">The events.</param>
-        /// <param name="state">The state.</param>
         /// <returns>Returns the node that has been parsed.</returns>
-        static internal YamlNode ParseNode(EventReader events, DocumentLoadingState state)
+        static internal YamlNode ParseNode(IParser parser, DocumentLoadingState state)
         {
-            if (events.Accept<Scalar>())
+            if (parser.Accept<Scalar>())
             {
-                return new YamlScalarNode(events, state);
+                return new YamlScalarNode(parser, state);
             }
 
-            if (events.Accept<SequenceStart>())
+            if (parser.Accept<SequenceStart>())
             {
-                return new YamlSequenceNode(events, state);
+                return new YamlSequenceNode(parser, state);
             }
 
-            if (events.Accept<MappingStart>())
+            if (parser.Accept<MappingStart>())
             {
-                return new YamlMappingNode(events, state);
+                return new YamlMappingNode(parser, state);
             }
 
-            if (events.Accept<AnchorAlias>())
+            if (parser.Accept<AnchorAlias>())
             {
-                AnchorAlias alias = events.Expect<AnchorAlias>();
+                AnchorAlias alias = parser.Expect<AnchorAlias>();
                 return state.GetNode(alias.Value, false, alias.Start, alias.End) ?? new YamlAliasNode(alias.Value);
             }
 
diff --git a/YamlDotNet/RepresentationModel/YamlScalarNode.cs b/YamlDotNet/RepresentationModel/YamlScalarNode.cs
index 6c9904317..4e5667cb2 100644
--- a/YamlDotNet/RepresentationModel/YamlScalarNode.cs
+++ b/YamlDotNet/RepresentationModel/YamlScalarNode.cs
@@ -51,16 +51,14 @@ public class YamlScalarNode : YamlNode, IYamlConvertible
         /// <summary>
         /// Initializes a new instance of the <see cref="YamlScalarNode"/> class.
         /// </summary>
-        /// <param name="events">The events.</param>
-        /// <param name="state">The state.</param>
-        internal YamlScalarNode(EventReader events, DocumentLoadingState state)
+        internal YamlScalarNode(IParser parser, DocumentLoadingState state)
         {
-            Load(events, state);
+            Load(parser, state);
         }
 
-        private void Load(EventReader events, DocumentLoadingState state)
+        private void Load(IParser parser, DocumentLoadingState state)
         {
-            Scalar scalar = events.Expect<Scalar>();
+            Scalar scalar = parser.Expect<Scalar>();
             base.Load(scalar, state);
             Value = scalar.Value;
             Style = scalar.Style;
@@ -169,9 +167,9 @@ public override YamlNodeType NodeType
             get { return YamlNodeType.Scalar; }
         }
 
-        void IYamlConvertible.Read(EventReader reader, Type expectedType, Func<EventReader, Type, object> nestedObjectDeserializer)
+        void IYamlConvertible.Read(IParser parser, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer)
         {
-            Load(reader, new DocumentLoadingState());
+            Load(parser, new DocumentLoadingState());
         }
 
         void IYamlConvertible.Write(IEmitter emitter)
diff --git a/YamlDotNet/RepresentationModel/YamlSequenceNode.cs b/YamlDotNet/RepresentationModel/YamlSequenceNode.cs
index 222571af2..e8152654b 100644
--- a/YamlDotNet/RepresentationModel/YamlSequenceNode.cs
+++ b/YamlDotNet/RepresentationModel/YamlSequenceNode.cs
@@ -61,23 +61,21 @@ public IList<YamlNode> Children
         /// <summary>
         /// Initializes a new instance of the <see cref="YamlSequenceNode"/> class.
         /// </summary>
-        /// <param name="events">The events.</param>
-        /// <param name="state">The state.</param>
-        internal YamlSequenceNode(EventReader events, DocumentLoadingState state)
+        internal YamlSequenceNode(IParser parser, DocumentLoadingState state)
         {
-            Load(events, state);
+            Load(parser, state);
         }
 
-        private void Load(EventReader events, DocumentLoadingState state)
+        private void Load(IParser parser, DocumentLoadingState state)
         {
-            SequenceStart sequence = events.Expect<SequenceStart>();
+            SequenceStart sequence = parser.Expect<SequenceStart>();
             base.Load(sequence, state);
             Style = sequence.Style;
 
             bool hasUnresolvedAliases = false;
-            while (!events.Accept<SequenceEnd>())
+            while (!parser.Accept<SequenceEnd>())
             {
-                YamlNode child = ParseNode(events, state);
+                YamlNode child = ParseNode(parser, state);
                 children.Add(child);
                 hasUnresolvedAliases |= child is YamlAliasNode;
             }
@@ -99,7 +97,7 @@ private void Load(EventReader events, DocumentLoadingState state)
             }
 #endif
 
-            events.Expect<SequenceEnd>();
+            parser.Expect<SequenceEnd>();
         }
 
         /// <summary>
@@ -293,9 +291,9 @@ System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
 
         #endregion
 
-        void IYamlConvertible.Read(EventReader reader, Type expectedType, Func<EventReader, Type, object> nestedObjectDeserializer)
+        void IYamlConvertible.Read(IParser parser, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer)
         {
-            Load(reader, new DocumentLoadingState());
+            Load(parser, new DocumentLoadingState());
         }
 
         void IYamlConvertible.Write(IEmitter emitter)
diff --git a/YamlDotNet/RepresentationModel/YamlStream.cs b/YamlDotNet/RepresentationModel/YamlStream.cs
index 04858feaf..05cff580d 100644
--- a/YamlDotNet/RepresentationModel/YamlStream.cs
+++ b/YamlDotNet/RepresentationModel/YamlStream.cs
@@ -88,22 +88,22 @@ public void Add(YamlDocument document)
         /// <param name="input">The input.</param>
         public void Load(TextReader input)
         {
-            Load(new EventReader(new Parser(input)));
+            Load(new Parser(input));
         }
 
         /// <summary>
-        /// Loads the stream from the specified <see cref="EventReader"/>.
+        /// Loads the stream from the specified <see cref="IParser"/>.
         /// </summary>
-        public void Load(EventReader reader)
+        public void Load(IParser parser)
         {
             documents.Clear();
-            reader.Expect<StreamStart>();
-            while (!reader.Accept<StreamEnd>())
+            parser.Expect<StreamStart>();
+            while (!parser.Accept<StreamEnd>())
             {
-                YamlDocument document = new YamlDocument(reader);
+                YamlDocument document = new YamlDocument(parser);
                 documents.Add(document);
             }
-            reader.Expect<StreamEnd>();
+            parser.Expect<StreamEnd>();
         }
 
         /// <summary>
diff --git a/YamlDotNet/RepresentationModel/YamlVisitorBase.cs b/YamlDotNet/RepresentationModel/YamlVisitorBase.cs
index bfaa39720..74d1b649c 100644
--- a/YamlDotNet/RepresentationModel/YamlVisitorBase.cs
+++ b/YamlDotNet/RepresentationModel/YamlVisitorBase.cs
@@ -26,7 +26,8 @@ namespace YamlDotNet.RepresentationModel
     /// <summary>
     /// Abstract implementation of <see cref="IYamlVisitor"/> that knows how to walk a complete YAML object model.
     /// </summary>
-    public abstract class YamlVisitorBase : IYamlVisitor {
+    public abstract class YamlVisitorBase : IYamlVisitor
+    {
         /// <summary>
         /// Called when this object is visiting a <see cref="YamlStream"/>.
         /// </summary>
diff --git a/YamlDotNet/Serialization/Deserializer.cs b/YamlDotNet/Serialization/Deserializer.cs
index 90bdc0f1c..9bb9c4a89 100644
--- a/YamlDotNet/Serialization/Deserializer.cs
+++ b/YamlDotNet/Serialization/Deserializer.cs
@@ -156,28 +156,28 @@ public object Deserialize(TextReader input)
 
         public object Deserialize(TextReader input, Type type)
         {
-            return Deserialize(new EventReader(new Parser(input)), type);
+            return Deserialize(new Parser(input), type);
         }
 
-        public T Deserialize<T>(EventReader reader)
+        public T Deserialize<T>(IParser parser)
         {
-            return (T)Deserialize(reader, typeof(T));
+            return (T)Deserialize(parser, typeof(T));
         }
 
-        public object Deserialize(EventReader reader)
+        public object Deserialize(IParser parser)
         {
-            return Deserialize(reader, typeof(object));
+            return Deserialize(parser, typeof(object));
         }
 
         /// <summary>
         /// Deserializes an object of the specified type.
         /// </summary>
-        /// <param name="reader">The <see cref="EventReader" /> where to deserialize the object.</param>
+        /// <param name="parser">The <see cref="IParser" /> from where to deserialize the object.</param>
         /// <param name="type">The static type of the object to deserialize.</param>
         /// <returns>Returns the deserialized object.</returns>
-        public object Deserialize(EventReader reader, Type type)
+        public object Deserialize(IParser parser, Type type)
         {
-            if (reader == null)
+            if (parser == null)
             {
                 throw new ArgumentNullException("reader");
             }
@@ -187,28 +187,28 @@ public object Deserialize(EventReader reader, Type type)
                 throw new ArgumentNullException("type");
             }
 
-            var hasStreamStart = reader.Allow<StreamStart>() != null;
+            var hasStreamStart = parser.Allow<StreamStart>() != null;
 
-            var hasDocumentStart = reader.Allow<DocumentStart>() != null;
+            var hasDocumentStart = parser.Allow<DocumentStart>() != null;
 
             object result = null;
-            if (!reader.Accept<DocumentEnd>() && !reader.Accept<StreamEnd>())
+            if (!parser.Accept<DocumentEnd>() && !parser.Accept<StreamEnd>())
             {
                 using (var state = new SerializerState())
                 {
-                    result = valueDeserializer.DeserializeValue(reader, type, state, valueDeserializer);
+                    result = valueDeserializer.DeserializeValue(parser, type, state, valueDeserializer);
                     state.OnDeserialization();
                 }
             }
 
             if (hasDocumentStart)
             {
-                reader.Expect<DocumentEnd>();
+                parser.Expect<DocumentEnd>();
             }
 
             if (hasStreamStart)
             {
-                reader.Expect<StreamEnd>();
+                parser.Expect<StreamEnd>();
             }
 
             return result;
diff --git a/YamlDotNet/Serialization/INodeDeserializer.cs b/YamlDotNet/Serialization/INodeDeserializer.cs
index 4c78a858a..ac781da1f 100644
--- a/YamlDotNet/Serialization/INodeDeserializer.cs
+++ b/YamlDotNet/Serialization/INodeDeserializer.cs
@@ -26,6 +26,6 @@ namespace YamlDotNet.Serialization
 {
     public interface INodeDeserializer
     {
-        bool Deserialize(EventReader reader, Type expectedType, Func<EventReader, Type, object> nestedObjectDeserializer, out object value);
+        bool Deserialize(IParser reader, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value);
     }
 }
\ No newline at end of file
diff --git a/YamlDotNet/Serialization/IValueDeserializer.cs b/YamlDotNet/Serialization/IValueDeserializer.cs
index a94df498e..10e802c21 100644
--- a/YamlDotNet/Serialization/IValueDeserializer.cs
+++ b/YamlDotNet/Serialization/IValueDeserializer.cs
@@ -27,6 +27,6 @@ namespace YamlDotNet.Serialization
 {
     public interface IValueDeserializer
     {
-        object DeserializeValue(EventReader reader, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer);
+        object DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer);
     }
 }
diff --git a/YamlDotNet/Serialization/IYamlConvertible.cs b/YamlDotNet/Serialization/IYamlConvertible.cs
index 40ec3b412..b9f547b3d 100644
--- a/YamlDotNet/Serialization/IYamlConvertible.cs
+++ b/YamlDotNet/Serialization/IYamlConvertible.cs
@@ -32,7 +32,7 @@ public interface IYamlConvertible
         /// <summary>
         /// Reads this object's state from a YAML parser.
         /// </summary>
-        void Read(EventReader reader, Type expectedType, Func<EventReader, Type, object> nestedObjectDeserializer);
+        void Read(IParser parser, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer);
 
         /// <summary>
         /// Writes this object's state to a YAML emitter.
diff --git a/YamlDotNet/Serialization/NodeDeserializers/ArrayNodeDeserializer.cs b/YamlDotNet/Serialization/NodeDeserializers/ArrayNodeDeserializer.cs
index 71e74b515..09c74ea94 100644
--- a/YamlDotNet/Serialization/NodeDeserializers/ArrayNodeDeserializer.cs
+++ b/YamlDotNet/Serialization/NodeDeserializers/ArrayNodeDeserializer.cs
@@ -27,7 +27,7 @@ namespace YamlDotNet.Serialization.NodeDeserializers
 {
     public sealed class ArrayNodeDeserializer : INodeDeserializer
     {
-        bool INodeDeserializer.Deserialize(EventReader reader, Type expectedType, Func<EventReader, Type, object> nestedObjectDeserializer, out object value)
+        bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value)
         {
             if (!expectedType.IsArray)
             {
@@ -38,7 +38,7 @@ bool INodeDeserializer.Deserialize(EventReader reader, Type expectedType, Func<E
             var itemType = expectedType.GetElementType();
 
             var items = new ArrayList();
-            CollectionNodeDeserializer.DeserializeHelper(itemType, reader, expectedType, nestedObjectDeserializer, items, true);
+            CollectionNodeDeserializer.DeserializeHelper(itemType, parser, expectedType, nestedObjectDeserializer, items, true);
 
             var array = Array.CreateInstance(itemType, items.Count);
             items.CopyTo(array, 0);
diff --git a/YamlDotNet/Serialization/NodeDeserializers/CollectionNodeDeserializer.cs b/YamlDotNet/Serialization/NodeDeserializers/CollectionNodeDeserializer.cs
index 5ce0234d9..2659d698c 100644
--- a/YamlDotNet/Serialization/NodeDeserializers/CollectionNodeDeserializer.cs
+++ b/YamlDotNet/Serialization/NodeDeserializers/CollectionNodeDeserializer.cs
@@ -38,7 +38,7 @@ public CollectionNodeDeserializer(IObjectFactory objectFactory)
             _objectFactory = objectFactory;
         }
 
-        bool INodeDeserializer.Deserialize(EventReader reader, Type expectedType, Func<EventReader, Type, object> nestedObjectDeserializer, out object value)
+        bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value)
         {
             IList list;
             bool canUpdate = true;
@@ -71,19 +71,19 @@ bool INodeDeserializer.Deserialize(EventReader reader, Type expectedType, Func<E
                 return false;
             }
 
-            DeserializeHelper(itemType, reader, expectedType, nestedObjectDeserializer, list, canUpdate);
+            DeserializeHelper(itemType, parser, expectedType, nestedObjectDeserializer, list, canUpdate);
 
             return true;
         }
 
-        internal static void DeserializeHelper(Type tItem, EventReader reader, Type expectedType, Func<EventReader, Type, object> nestedObjectDeserializer, IList result, bool canUpdate)
+        internal static void DeserializeHelper(Type tItem, IParser parser, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, IList result, bool canUpdate)
         {
-            reader.Expect<SequenceStart>();
-            while (!reader.Accept<SequenceEnd>())
+            parser.Expect<SequenceStart>();
+            while (!parser.Accept<SequenceEnd>())
             {
-                var current = reader.Parser.Current;
+                var current = parser.Current;
 
-                var value = nestedObjectDeserializer(reader, tItem);
+                var value = nestedObjectDeserializer(parser, tItem);
                 var promise = value as IValuePromise;
                 if (promise == null)
                 {
@@ -103,7 +103,7 @@ internal static void DeserializeHelper(Type tItem, EventReader reader, Type expe
                     );
                 }
             }
-            reader.Expect<SequenceEnd>();
+            parser.Expect<SequenceEnd>();
         }        
     }
 }
diff --git a/YamlDotNet/Serialization/NodeDeserializers/DictionaryNodeDeserializer.cs b/YamlDotNet/Serialization/NodeDeserializers/DictionaryNodeDeserializer.cs
index e6d103856..b48565b75 100644
--- a/YamlDotNet/Serialization/NodeDeserializers/DictionaryNodeDeserializer.cs
+++ b/YamlDotNet/Serialization/NodeDeserializers/DictionaryNodeDeserializer.cs
@@ -38,7 +38,7 @@ public DictionaryNodeDeserializer(IObjectFactory objectFactory)
             _objectFactory = objectFactory;
         }
 
-        bool INodeDeserializer.Deserialize(EventReader reader, Type expectedType, Func<EventReader, Type, object> nestedObjectDeserializer, out object value)
+        bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value)
         {
             IDictionary dictionary;
             Type keyType, valueType;
@@ -71,20 +71,20 @@ bool INodeDeserializer.Deserialize(EventReader reader, Type expectedType, Func<E
                 return false;
             }
 
-            DeserializeHelper(keyType, valueType, reader, expectedType, nestedObjectDeserializer, dictionary);
+            DeserializeHelper(keyType, valueType, parser, expectedType, nestedObjectDeserializer, dictionary);
 
             return true;
         }
 
-        private static void DeserializeHelper(Type tKey, Type tValue, EventReader reader, Type expectedType, Func<EventReader, Type, object> nestedObjectDeserializer, IDictionary result)
+        private static void DeserializeHelper(Type tKey, Type tValue, IParser parser, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, IDictionary result)
         {
-            reader.Expect<MappingStart>();
-            while (!reader.Accept<MappingEnd>())
+            parser.Expect<MappingStart>();
+            while (!parser.Accept<MappingEnd>())
             {
-                var key = nestedObjectDeserializer(reader, tKey);
+                var key = nestedObjectDeserializer(parser, tKey);
                 var keyPromise = key as IValuePromise;
 
-                var value = nestedObjectDeserializer(reader, tValue);
+                var value = nestedObjectDeserializer(parser, tValue);
                 var valuePromise = value as IValuePromise;
 
                 if (keyPromise == null)
@@ -140,7 +140,7 @@ private static void DeserializeHelper(Type tKey, Type tValue, EventReader reader
                     }
                 }
             }
-            reader.Expect<MappingEnd>();
+            parser.Expect<MappingEnd>();
         }
     }
 }
\ No newline at end of file
diff --git a/YamlDotNet/Serialization/NodeDeserializers/EnumerableNodeDeserializer.cs b/YamlDotNet/Serialization/NodeDeserializers/EnumerableNodeDeserializer.cs
index 7d27e8811..0ff638816 100644
--- a/YamlDotNet/Serialization/NodeDeserializers/EnumerableNodeDeserializer.cs
+++ b/YamlDotNet/Serialization/NodeDeserializers/EnumerableNodeDeserializer.cs
@@ -29,7 +29,7 @@ namespace YamlDotNet.Serialization.NodeDeserializers
 {
     public sealed class EnumerableNodeDeserializer : INodeDeserializer
     {
-        bool INodeDeserializer.Deserialize(EventReader reader, Type expectedType, Func<EventReader, Type, object> nestedObjectDeserializer, out object value)
+        bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value)
         {
             Type itemsType;
             if (expectedType == typeof(IEnumerable))
@@ -49,7 +49,7 @@ bool INodeDeserializer.Deserialize(EventReader reader, Type expectedType, Func<E
             }
 
             var collectionType = typeof(List<>).MakeGenericType(itemsType);
-            value = nestedObjectDeserializer(reader, collectionType);
+            value = nestedObjectDeserializer(parser, collectionType);
             return true;
         }
     }
diff --git a/YamlDotNet/Serialization/NodeDeserializers/NullNodeDeserializer.cs b/YamlDotNet/Serialization/NodeDeserializers/NullNodeDeserializer.cs
index 82914c534..d67eaea1c 100644
--- a/YamlDotNet/Serialization/NodeDeserializers/NullNodeDeserializer.cs
+++ b/YamlDotNet/Serialization/NodeDeserializers/NullNodeDeserializer.cs
@@ -27,16 +27,16 @@ namespace YamlDotNet.Serialization.NodeDeserializers
 {
     public sealed class NullNodeDeserializer : INodeDeserializer
     {
-        bool INodeDeserializer.Deserialize(EventReader reader, Type expectedType, Func<EventReader, Type, object> nestedObjectDeserializer, out object value)
+        bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value)
         {
             value = null;
-            var evt = reader.Peek<NodeEvent>();
+            var evt = parser.Peek<NodeEvent>();
             var isNull = evt != null
                 && NodeIsNull(evt);
 
             if (isNull)
             {
-                reader.SkipThisAndNestedEvents();
+                parser.SkipThisAndNestedEvents();
             }
             return isNull;
         }
diff --git a/YamlDotNet/Serialization/NodeDeserializers/ObjectNodeDeserializer.cs b/YamlDotNet/Serialization/NodeDeserializers/ObjectNodeDeserializer.cs
index 2da537c30..e4aebab77 100644
--- a/YamlDotNet/Serialization/NodeDeserializers/ObjectNodeDeserializer.cs
+++ b/YamlDotNet/Serialization/NodeDeserializers/ObjectNodeDeserializer.cs
@@ -42,9 +42,9 @@ public ObjectNodeDeserializer(IObjectFactory objectFactory, ITypeInspector typeD
             _ignoreUnmatched = ignoreUnmatched;
         }
 
-        bool INodeDeserializer.Deserialize(EventReader reader, Type expectedType, Func<EventReader, Type, object> nestedObjectDeserializer, out object value)
+        bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value)
         {
-            var mapping = reader.Allow<MappingStart>();
+            var mapping = parser.Allow<MappingStart>();
             if (mapping == null)
             {
                 value = null;
@@ -52,17 +52,17 @@ bool INodeDeserializer.Deserialize(EventReader reader, Type expectedType, Func<E
             }
             
             value = _objectFactory.Create(expectedType);
-            while (!reader.Accept<MappingEnd>())
+            while (!parser.Accept<MappingEnd>())
             {
-                var propertyName = reader.Expect<Scalar>();
+                var propertyName = parser.Expect<Scalar>();
                 var property = _typeDescriptor.GetProperty(expectedType, null, propertyName.Value, _ignoreUnmatched);
                 if (property == null)
                 {
-                    reader.SkipThisAndNestedEvents();
+                    parser.SkipThisAndNestedEvents();
                     continue;
                 }
 
-                var propertyValue = nestedObjectDeserializer(reader, property.Type);
+                var propertyValue = nestedObjectDeserializer(parser, property.Type);
                 var propertyValuePromise = propertyValue as IValuePromise;
                 if (propertyValuePromise == null)
                 {
@@ -80,7 +80,7 @@ bool INodeDeserializer.Deserialize(EventReader reader, Type expectedType, Func<E
                 }
             }
 
-            reader.Expect<MappingEnd>();
+            parser.Expect<MappingEnd>();
             return true;
         }
     }
diff --git a/YamlDotNet/Serialization/NodeDeserializers/ScalarNodeDeserializer.cs b/YamlDotNet/Serialization/NodeDeserializers/ScalarNodeDeserializer.cs
index 7f213bc5b..af01a3cb2 100644
--- a/YamlDotNet/Serialization/NodeDeserializers/ScalarNodeDeserializer.cs
+++ b/YamlDotNet/Serialization/NodeDeserializers/ScalarNodeDeserializer.cs
@@ -34,9 +34,9 @@ public sealed class ScalarNodeDeserializer : INodeDeserializer
         private const string BooleanTruePattern = "^(true|y|yes|on)$";
         private const string BooleanFalsePattern = "^(false|n|no|off)$";
 
-        bool INodeDeserializer.Deserialize(EventReader reader, Type expectedType, Func<EventReader, Type, object> nestedObjectDeserializer, out object value)
+        bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value)
         {
-            var scalar = reader.Allow<Scalar>();
+            var scalar = parser.Allow<Scalar>();
             if (scalar == null)
             {
                 value = null;
diff --git a/YamlDotNet/Serialization/NodeDeserializers/TypeConverterNodeDeserializer.cs b/YamlDotNet/Serialization/NodeDeserializers/TypeConverterNodeDeserializer.cs
index b86157fe1..833d295ea 100644
--- a/YamlDotNet/Serialization/NodeDeserializers/TypeConverterNodeDeserializer.cs
+++ b/YamlDotNet/Serialization/NodeDeserializers/TypeConverterNodeDeserializer.cs
@@ -40,7 +40,7 @@ public TypeConverterNodeDeserializer(IEnumerable<IYamlTypeConverter> converters)
             this.converters = converters;
         }
 
-        bool INodeDeserializer.Deserialize(EventReader reader, Type expectedType, Func<EventReader, Type, object> nestedObjectDeserializer, out object value)
+        bool INodeDeserializer.Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value)
         {
             var converter = converters.FirstOrDefault(c => c.Accepts(expectedType));
             if (converter == null)
@@ -49,7 +49,7 @@ bool INodeDeserializer.Deserialize(EventReader reader, Type expectedType, Func<E
                 return false;
             }
 
-            value = converter.ReadYaml(reader.Parser, expectedType);
+            value = converter.ReadYaml(parser, expectedType);
             return true;
         }
     }
diff --git a/YamlDotNet/Serialization/NodeDeserializers/YamlConvertibleNodeDeserializer.cs b/YamlDotNet/Serialization/NodeDeserializers/YamlConvertibleNodeDeserializer.cs
index 847bec0ef..c8311f9ea 100644
--- a/YamlDotNet/Serialization/NodeDeserializers/YamlConvertibleNodeDeserializer.cs
+++ b/YamlDotNet/Serialization/NodeDeserializers/YamlConvertibleNodeDeserializer.cs
@@ -33,12 +33,12 @@ public YamlConvertibleNodeDeserializer(IObjectFactory objectFactory)
 			this.objectFactory = objectFactory;
         }
     
-        public bool Deserialize(EventReader reader, Type expectedType, Func<EventReader, Type, object> nestedObjectDeserializer, out object value)
+        public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value)
         {
             if (typeof(IYamlConvertible).IsAssignableFrom(expectedType))
             {
                 var convertible = (IYamlConvertible)objectFactory.Create(expectedType);
-                convertible.Read(reader, expectedType, nestedObjectDeserializer);
+                convertible.Read(parser, expectedType, nestedObjectDeserializer);
                 value = convertible;
                 return true;
             }
diff --git a/YamlDotNet/Serialization/NodeDeserializers/YamlSerializableNodeDeserializer.cs b/YamlDotNet/Serialization/NodeDeserializers/YamlSerializableNodeDeserializer.cs
index e5222d01b..db179a70c 100644
--- a/YamlDotNet/Serialization/NodeDeserializers/YamlSerializableNodeDeserializer.cs
+++ b/YamlDotNet/Serialization/NodeDeserializers/YamlSerializableNodeDeserializer.cs
@@ -33,13 +33,13 @@ public YamlSerializableNodeDeserializer(IObjectFactory objectFactory)
 			this.objectFactory = objectFactory;
         }
     
-        public bool Deserialize(EventReader reader, Type expectedType, Func<EventReader, Type, object> nestedObjectDeserializer, out object value)
+        public bool Deserialize(IParser parser, Type expectedType, Func<IParser, Type, object> nestedObjectDeserializer, out object value)
         {
 #pragma warning disable 0618 // IYamlSerializable is obsolete
             if (typeof(IYamlSerializable).IsAssignableFrom(expectedType))
             {
                 var serializable = (IYamlSerializable)objectFactory.Create(expectedType);
-                serializable.ReadYaml(reader.Parser);
+                serializable.ReadYaml(parser);
                 value = serializable;
                 return true;
             }
diff --git a/YamlDotNet/Serialization/ValueDeserializers/AliasValueDeserializer.cs b/YamlDotNet/Serialization/ValueDeserializers/AliasValueDeserializer.cs
index b4ad68029..5ce7e4f8d 100644
--- a/YamlDotNet/Serialization/ValueDeserializers/AliasValueDeserializer.cs
+++ b/YamlDotNet/Serialization/ValueDeserializers/AliasValueDeserializer.cs
@@ -106,10 +106,10 @@ public object Value
             }
         }
         
-        public object DeserializeValue (EventReader reader, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
+        public object DeserializeValue (IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
         {
             object value;
-            var alias = reader.Allow<AnchorAlias>();
+            var alias = parser.Allow<AnchorAlias>();
             if(alias != null)
             {
                 var aliasState = state.Get<AliasState>();
@@ -125,13 +125,13 @@ public object DeserializeValue (EventReader reader, Type expectedType, Serialize
             
             string anchor = null;
             
-            var nodeEvent = reader.Peek<NodeEvent>();
+            var nodeEvent = parser.Peek<NodeEvent>();
             if(nodeEvent != null && !string.IsNullOrEmpty(nodeEvent.Anchor))
             {
                 anchor = nodeEvent.Anchor;
             }
             
-            value = innerDeserializer.DeserializeValue(reader, expectedType, state, nestedObjectDeserializer);
+            value = innerDeserializer.DeserializeValue(parser, expectedType, state, nestedObjectDeserializer);
             
             if(anchor != null)
             {
diff --git a/YamlDotNet/Serialization/ValueDeserializers/NodeValueDeserializer.cs b/YamlDotNet/Serialization/ValueDeserializers/NodeValueDeserializer.cs
index 96986b1d5..9647aeb49 100644
--- a/YamlDotNet/Serialization/ValueDeserializers/NodeValueDeserializer.cs
+++ b/YamlDotNet/Serialization/ValueDeserializers/NodeValueDeserializer.cs
@@ -49,9 +49,9 @@ public NodeValueDeserializer(IList<INodeDeserializer> deserializers, IList<INode
             this.typeResolvers = typeResolvers;
         }
         
-        public object DeserializeValue (EventReader reader, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
+        public object DeserializeValue (IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
         {
-            var nodeEvent = reader.Peek<NodeEvent>();
+            var nodeEvent = parser.Peek<NodeEvent>();
 
             var nodeType = GetTypeFromEvent(nodeEvent, expectedType);
 
@@ -60,7 +60,7 @@ public object DeserializeValue (EventReader reader, Type expectedType, Serialize
                 foreach (var deserializer in deserializers)
                 {
                     object value;
-                    if (deserializer.Deserialize(reader, nodeType, (r, t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out value))
+                    if (deserializer.Deserialize(parser, nodeType, (r, t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out value))
                     {
                         return value;
                     }
diff --git a/YamlDotNet/YamlDotNet.csproj b/YamlDotNet/YamlDotNet.csproj
index 6eefca24f..6919089d6 100644
--- a/YamlDotNet/YamlDotNet.csproj
+++ b/YamlDotNet/YamlDotNet.csproj
@@ -151,7 +151,7 @@
     <Compile Include="Core\DuplicateAnchorException.cs" />
     <Compile Include="Core\Emitter.cs" />
     <Compile Include="Core\EmitterState.cs" />
-    <Compile Include="Core\EventReader.cs" />
+    <Compile Include="Core\ParserExtensions.cs" />
     <Compile Include="Core\Events\AnchorAlias.cs" />
     <Compile Include="Core\Events\Comment.cs" />
     <Compile Include="Core\Events\DocumentEnd.cs" />