cssesc-source 0.1.0

data/vendor/node_modules/grunt/node_modules/js-yaml/lib/js-yaml/loader.js

@@ -0,0 +1,1549 @@
+'use strict';
+
+
+var common         = require('./common');
+var YAMLException  = require('./exception');
+var Mark           = require('./mark');
+var NIL            = common.NIL;
+var SAFE_SCHEMA    = require('./schema/safe');
+var DEFAULT_SCHEMA = require('./schema/default');
+
+
+var _hasOwnProperty = Object.prototype.hasOwnProperty;
+
+
+var KIND_STRING = 'string';
+var KIND_ARRAY  = 'array';
+var KIND_OBJECT = 'object';
+
+
+var CONTEXT_FLOW_IN   = 1;
+var CONTEXT_FLOW_OUT  = 2;
+var CONTEXT_BLOCK_IN  = 3;
+var CONTEXT_BLOCK_OUT = 4;
+
+
+var CHOMPING_CLIP  = 1;
+var CHOMPING_STRIP = 2;
+var CHOMPING_KEEP  = 3;
+
+
+var CHAR_TAB                  = 0x09;   /* Tab */
+var CHAR_LINE_FEED            = 0x0A;   /* LF */
+var CHAR_CARRIAGE_RETURN      = 0x0D;   /* CR */
+var CHAR_SPACE                = 0x20;   /* Space */
+var CHAR_EXCLAMATION          = 0x21;   /* ! */
+var CHAR_DOUBLE_QUOTE         = 0x22;   /* " */
+var CHAR_SHARP                = 0x23;   /* # */
+var CHAR_PERCENT              = 0x25;   /* % */
+var CHAR_AMPERSAND            = 0x26;   /* & */
+var CHAR_SINGLE_QUOTE         = 0x27;   /* ' */
+var CHAR_ASTERISK             = 0x2A;   /* * */
+var CHAR_PLUS                 = 0x2B;   /* + */
+var CHAR_COMMA                = 0x2C;   /* , */
+var CHAR_MINUS                = 0x2D;   /* - */
+var CHAR_DOT                  = 0x2E;   /* . */
+var CHAR_SLASH                = 0x2F;   /* / */
+var CHAR_DIGIT_ZERO           = 0x30;   /* 0 */
+var CHAR_DIGIT_ONE            = 0x31;   /* 1 */
+var CHAR_DIGIT_NINE           = 0x39;   /* 9 */
+var CHAR_COLON                = 0x3A;   /* : */
+var CHAR_LESS_THAN            = 0x3C;   /* < */
+var CHAR_GREATER_THAN         = 0x3E;   /* > */
+var CHAR_QUESTION             = 0x3F;   /* ? */
+var CHAR_COMMERCIAL_AT        = 0x40;   /* @ */
+var CHAR_CAPITAL_A            = 0x41;   /* A */
+var CHAR_CAPITAL_F            = 0x46;   /* F */
+var CHAR_CAPITAL_L            = 0x4C;   /* L */
+var CHAR_CAPITAL_N            = 0x4E;   /* N */
+var CHAR_CAPITAL_P            = 0x50;   /* P */
+var CHAR_CAPITAL_U            = 0x55;   /* U */
+var CHAR_LEFT_SQUARE_BRACKET  = 0x5B;   /* [ */
+var CHAR_BACKSLASH            = 0x5C;   /* \ */
+var CHAR_RIGHT_SQUARE_BRACKET = 0x5D;   /* ] */
+var CHAR_UNDERSCORE           = 0x5F;   /* _ */
+var CHAR_GRAVE_ACCENT         = 0x60;   /* ` */
+var CHAR_SMALL_A              = 0x61;   /* a */
+var CHAR_SMALL_B              = 0x62;   /* b */
+var CHAR_SMALL_E              = 0x65;   /* e */
+var CHAR_SMALL_F              = 0x66;   /* f */
+var CHAR_SMALL_N              = 0x6E;   /* n */
+var CHAR_SMALL_R              = 0x72;   /* r */
+var CHAR_SMALL_T              = 0x74;   /* t */
+var CHAR_SMALL_U              = 0x75;   /* u */
+var CHAR_SMALL_V              = 0x76;   /* v */
+var CHAR_SMALL_X              = 0x78;   /* x */
+var CHAR_LEFT_CURLY_BRACKET   = 0x7B;   /* { */
+var CHAR_VERTICAL_LINE        = 0x7C;   /* | */
+var CHAR_RIGHT_CURLY_BRACKET  = 0x7D;   /* } */
+
+
+var SIMPLE_ESCAPE_SEQUENCES = {};
+
+SIMPLE_ESCAPE_SEQUENCES[CHAR_DIGIT_ZERO]   = '\x00';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_SMALL_A]      = '\x07';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_SMALL_B]      = '\x08';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_SMALL_T]      = '\x09';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_TAB]          = '\x09';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_SMALL_N]      = '\x0A';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_SMALL_V]      = '\x0B';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_SMALL_F]      = '\x0C';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_SMALL_R]      = '\x0D';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_SMALL_E]      = '\x1B';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_SPACE]        = ' ';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_DOUBLE_QUOTE] = '\x22';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_SLASH]        = '/';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_BACKSLASH]    = '\x5C';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_CAPITAL_N]    = '\x85';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_UNDERSCORE]   = '\xA0';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_CAPITAL_L]    = '\u2028';
+SIMPLE_ESCAPE_SEQUENCES[CHAR_CAPITAL_P]    = '\u2029';
+
+
+var HEXADECIMAL_ESCAPE_SEQUENCES = {};
+
+HEXADECIMAL_ESCAPE_SEQUENCES[CHAR_SMALL_X]   = 2;
+HEXADECIMAL_ESCAPE_SEQUENCES[CHAR_SMALL_U]   = 4;
+HEXADECIMAL_ESCAPE_SEQUENCES[CHAR_CAPITAL_U] = 8;
+
+
+var PATTERN_NON_PRINTABLE         = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uD800-\uDFFF\uFFFE\uFFFF]/;
+var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
+var PATTERN_FLOW_INDICATORS       = /[,\[\]\{\}]/;
+var PATTERN_TAG_HANDLE            = /^(?:!|!!|![a-z\-]+!)$/i;
+var PATTERN_TAG_URI               = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
+
+
+function loadAll(input, output, options) {
+  options = options || {};
+
+  var filename = options['filename'] || null,
+      schema   = options['schema']   || DEFAULT_SCHEMA,
+      resolve  = options['resolve']  || true,
+      validate = options['validate'] || true,
+      strict   = options['strict']   || false,
+      legacy   = options['legacy']   || false,
+
+      directiveHandlers = {},
+      implicitTypes     = schema.compiledImplicit,
+      typeMap           = schema.compiledTypeMap,
+
+      length     = input.length,
+      position   = 0,
+      line       = 0,
+      lineStart  = 0,
+      lineIndent = 0,
+      character  = input.charCodeAt(position),
+
+      version,
+      checkLineBreaks,
+      tagMap,
+      anchorMap,
+      tag,
+      anchor,
+      kind,
+      result;
+
+  function generateError(message) {
+    return new YAMLException(
+      message,
+      new Mark(filename, input, position, line, (position - lineStart)));
+  }
+
+  function throwError(message) {
+    throw generateError(message);
+  }
+
+  function throwWarning(message) {
+    var error = generateError(message);
+
+    if (strict) {
+      throw error;
+    } else {
+      console.warn(error.toString());
+    }
+  }
+
+  directiveHandlers['YAML'] = function handleYamlDirective(name, args) {
+    var match, major, minor;
+
+    if (null !== version) {
+      throwError('duplication of %YAML directive');
+    }
+
+    if (1 !== args.length) {
+      throwError('YAML directive accepts exactly one argument');
+    }
+
+    match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
+
+    if (null === match) {
+      throwError('ill-formed argument of the YAML directive');
+    }
+
+    major = parseInt(match[1], 10);
+    minor = parseInt(match[2], 10);
+
+    if (1 !== major) {
+      throwError('unacceptable YAML version of the document');
+    }
+
+    version = args[0];
+    checkLineBreaks = (minor < 2);
+
+    if (1 !== minor && 2 !== minor) {
+      throwWarning('unsupported YAML version of the document');
+    }
+  };
+
+  directiveHandlers['TAG'] = function handleTagDirective(name, args) {
+    var handle, prefix;
+
+    if (2 !== args.length) {
+      throwError('TAG directive accepts exactly two arguments');
+    }
+
+    handle = args[0];
+    prefix = args[1];
+
+    if (!PATTERN_TAG_HANDLE.test(handle)) {
+      throwError('ill-formed tag handle (first argument) of the TAG directive');
+    }
+
+    if (_hasOwnProperty.call(tagMap, handle)) {
+      throwError('there is a previously declared suffix for "' + handle + '" tag handle');
+    }
+
+    if (!PATTERN_TAG_URI.test(prefix)) {
+      throwError('ill-formed tag prefix (second argument) of the TAG directive');
+    }
+
+    tagMap[handle] = prefix;
+  };
+
+  function captureSegment(start, end, checkJson) {
+    var _position, _length, _character, _result;
+
+    if (start < end) {
+      _result = input.slice(start, end);
+
+      if (checkJson && validate) {
+        for (_position = 0, _length = _result.length;
+             _position < _length;
+             _position += 1) {
+          _character = _result.charCodeAt(_position);
+          if (!(0x09 === _character ||
+                0x20 <= _character && _character <= 0x10FFFF)) {
+            throwError('expected valid JSON character');
+          }
+        }
+      }
+
+      result += _result;
+    }
+  }
+
+  function mergeMappings(destination, source) {
+    var sourceKeys, key, index, quantity;
+
+    if (!common.isObject(source)) {
+      throwError('cannot merge mappings; the provided source object is unacceptable');
+    }
+
+    sourceKeys = Object.keys(source);
+
+    for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
+      key = sourceKeys[index];
+
+      if (!_hasOwnProperty.call(destination, key)) {
+        destination[key] = source[key];
+      }
+    }
+  }
+
+  function storeMappingPair(_result, keyTag, keyNode, valueNode) {
+    var index, quantity;
+
+    keyNode = String(keyNode);
+
+    if (null === _result) {
+      _result = {};
+    }
+
+    if ('tag:yaml.org,2002:merge' === keyTag) {
+      if (Array.isArray(valueNode)) {
+        for (index = 0, quantity = valueNode.length; index < quantity; index += 1) {
+          mergeMappings(_result, valueNode[index]);
+        }
+      } else {
+        mergeMappings(_result, valueNode);
+      }
+    } else {
+      _result[keyNode] = valueNode;
+    }
+
+    return _result;
+  }
+
+  function readLineBreak() {
+    if (CHAR_LINE_FEED === character) {
+      position += 1;
+    } else if (CHAR_CARRIAGE_RETURN === character) {
+      if (CHAR_LINE_FEED === input.charCodeAt(position + 1)) {
+        position += 2;
+      } else {
+        position += 1;
+      }
+    } else {
+      throwError('a line break is expected');
+    }
+
+    line += 1;
+    lineStart = position;
+    character = input.charCodeAt(position);
+  }
+
+  function skipSeparationSpace(allowComments, checkIndent) {
+    var lineBreaks = 0;
+
+    while (position < length) {
+      while (CHAR_SPACE === character || CHAR_TAB === character) {
+        character = input.charCodeAt(++position);
+      }
+
+      if (allowComments && CHAR_SHARP === character) {
+        do { character = input.charCodeAt(++position); }
+        while (position < length &&
+               CHAR_LINE_FEED !== character &&
+               CHAR_CARRIAGE_RETURN !== character);
+      }
+
+      if (CHAR_LINE_FEED === character || CHAR_CARRIAGE_RETURN === character) {
+        readLineBreak();
+        lineBreaks += 1;
+        lineIndent = 0;
+
+        while (CHAR_SPACE === character) {
+          lineIndent += 1;
+          character = input.charCodeAt(++position);
+        }
+
+        if (lineIndent < checkIndent) {
+          throwWarning('deficient indentation');
+        }
+      } else {
+        break;
+      }
+    }
+
+    return lineBreaks;
+  }
+
+  function testDocumentSeparator() {
+    var _position, _character;
+
+    if (position === lineStart &&
+        (CHAR_MINUS === character || CHAR_DOT === character) &&
+        input.charCodeAt(position + 1) === character &&
+        input.charCodeAt(position + 2) === character) {
+
+      _position = position + 3;
+      _character = input.charCodeAt(_position);
+
+      if (_position >= length ||
+          CHAR_SPACE           === _character ||
+          CHAR_TAB             === _character ||
+          CHAR_LINE_FEED       === _character ||
+          CHAR_CARRIAGE_RETURN === _character) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  function writeFoldedLines(count) {
+    if (1 === count) {
+      result += ' ';
+    } else if (count > 1) {
+      result += common.repeat('\n', count - 1);
+    }
+  }
+
+  function readPlainScalar(nodeIndent, withinFlowCollection) {
+    var preceding,
+        following,
+        captureStart,
+        captureEnd,
+        hasPendingContent,
+        _line,
+        _lineStart,
+        _lineIndent,
+        _kind = kind,
+        _result = result;
+
+    if (CHAR_SPACE                === character ||
+        CHAR_TAB                  === character ||
+        CHAR_LINE_FEED            === character ||
+        CHAR_CARRIAGE_RETURN      === character ||
+        CHAR_COMMA                === character ||
+        CHAR_LEFT_SQUARE_BRACKET  === character ||
+        CHAR_RIGHT_SQUARE_BRACKET === character ||
+        CHAR_LEFT_CURLY_BRACKET   === character ||
+        CHAR_RIGHT_CURLY_BRACKET  === character ||
+        CHAR_SHARP                === character ||
+        CHAR_AMPERSAND            === character ||
+        CHAR_ASTERISK             === character ||
+        CHAR_EXCLAMATION          === character ||
+        CHAR_VERTICAL_LINE        === character ||
+        CHAR_GREATER_THAN         === character ||
+        CHAR_SINGLE_QUOTE         === character ||
+        CHAR_DOUBLE_QUOTE         === character ||
+        CHAR_PERCENT              === character ||
+        CHAR_COMMERCIAL_AT        === character ||
+        CHAR_GRAVE_ACCENT         === character) {
+      return false;
+    }
+
+    if (CHAR_QUESTION === character ||
+        CHAR_MINUS === character) {
+      following = input.charCodeAt(position + 1);
+
+      if (CHAR_SPACE                 === following ||
+          CHAR_TAB                   === following ||
+          CHAR_LINE_FEED             === following ||
+          CHAR_CARRIAGE_RETURN       === following ||
+          withinFlowCollection &&
+          (CHAR_COMMA                === following ||
+           CHAR_LEFT_SQUARE_BRACKET  === following ||
+           CHAR_RIGHT_SQUARE_BRACKET === following ||
+           CHAR_LEFT_CURLY_BRACKET   === following ||
+           CHAR_RIGHT_CURLY_BRACKET  === following)) {
+        return false;
+      }
+    }
+
+    kind = KIND_STRING;
+    result = '';
+    captureStart = captureEnd = position;
+    hasPendingContent = false;
+
+    while (position < length) {
+      if (CHAR_COLON === character) {
+        following = input.charCodeAt(position + 1);
+
+        if (CHAR_SPACE                 === following ||
+            CHAR_TAB                   === following ||
+            CHAR_LINE_FEED             === following ||
+            CHAR_CARRIAGE_RETURN       === following ||
+            withinFlowCollection &&
+            (CHAR_COMMA                === following ||
+             CHAR_LEFT_SQUARE_BRACKET  === following ||
+             CHAR_RIGHT_SQUARE_BRACKET === following ||
+             CHAR_LEFT_CURLY_BRACKET   === following ||
+             CHAR_RIGHT_CURLY_BRACKET  === following)) {
+          break;
+        }
+
+      } else if (CHAR_SHARP === character) {
+        preceding = input.charCodeAt(position - 1);
+
+        if (CHAR_SPACE           === preceding ||
+            CHAR_TAB             === preceding ||
+            CHAR_LINE_FEED       === preceding ||
+            CHAR_CARRIAGE_RETURN === preceding) {
+          break;
+        }
+
+      } else if ((position === lineStart && testDocumentSeparator()) ||
+                 withinFlowCollection &&
+                 (CHAR_COMMA                === character ||
+                  CHAR_LEFT_SQUARE_BRACKET  === character ||
+                  CHAR_RIGHT_SQUARE_BRACKET === character ||
+                  CHAR_LEFT_CURLY_BRACKET   === character ||
+                  CHAR_RIGHT_CURLY_BRACKET  === character)) {
+        break;
+
+      } else if (CHAR_LINE_FEED === character ||
+                 CHAR_CARRIAGE_RETURN === character) {
+        _line = line;
+        _lineStart = lineStart;
+        _lineIndent = lineIndent;
+        skipSeparationSpace(false, -1);
+
+        if (lineIndent >= nodeIndent) {
+          hasPendingContent = true;
+          continue;
+        } else {
+          position = captureEnd;
+          line = _line;
+          lineStart = _lineStart;
+          lineIndent = _lineIndent;
+          character = input.charCodeAt(position);
+          break;
+        }
+      }
+
+      if (hasPendingContent) {
+        captureSegment(captureStart, captureEnd, false);
+        writeFoldedLines(line - _line);
+        captureStart = captureEnd = position;
+        hasPendingContent = false;
+      }
+
+      if (CHAR_SPACE !== character && CHAR_TAB !== character) {
+        captureEnd = position + 1;
+      }
+
+      character = input.charCodeAt(++position);
+    }
+
+    captureSegment(captureStart, captureEnd, false);
+
+    if (result) {
+      return true;
+    } else {
+      kind = _kind;
+      result = _result;
+      return false;
+    }
+  }
+
+  function readSingleQuotedScalar(nodeIndent) {
+    var captureStart, captureEnd;
+
+    if (CHAR_SINGLE_QUOTE !== character) {
+      return false;
+    }
+
+    kind = KIND_STRING;
+    result = '';
+    character = input.charCodeAt(++position);
+    captureStart = captureEnd = position;
+
+    while (position < length) {
+      if (CHAR_SINGLE_QUOTE === character) {
+        captureSegment(captureStart, position, true);
+        character = input.charCodeAt(++position);
+
+        if (CHAR_SINGLE_QUOTE === character) {
+          captureStart = captureEnd = position;
+          character = input.charCodeAt(++position);
+        } else {
+          return true;
+        }
+
+      } else if (CHAR_LINE_FEED === character ||
+                 CHAR_CARRIAGE_RETURN === character) {
+        captureSegment(captureStart, captureEnd, true);
+        writeFoldedLines(skipSeparationSpace(false, nodeIndent));
+        captureStart = captureEnd = position;
+        character = input.charCodeAt(position);
+
+      } else if (position === lineStart && testDocumentSeparator()) {
+        throwError('unexpected end of the document within a single quoted scalar');
+
+      } else {
+        character = input.charCodeAt(++position);
+        captureEnd = position;
+      }
+    }
+
+    throwError('unexpected end of the stream within a single quoted scalar');
+  }
+
+  function readDoubleQuotedScalar(nodeIndent) {
+    var captureStart,
+        captureEnd,
+        hexLength,
+        hexIndex,
+        hexOffset,
+        hexResult;
+
+    if (CHAR_DOUBLE_QUOTE !== character) {
+      return false;
+    }
+
+    kind = KIND_STRING;
+    result = '';
+    character = input.charCodeAt(++position);
+    captureStart = captureEnd = position;
+
+    while (position < length) {
+      if (CHAR_DOUBLE_QUOTE === character) {
+        captureSegment(captureStart, position, true);
+        character = input.charCodeAt(++position);
+        return true;
+
+      } else if (CHAR_BACKSLASH === character) {
+        captureSegment(captureStart, position, true);
+        character = input.charCodeAt(++position);
+
+        if (CHAR_LINE_FEED       === character ||
+            CHAR_CARRIAGE_RETURN === character) {
+          skipSeparationSpace(false, nodeIndent);
+
+        } else if (SIMPLE_ESCAPE_SEQUENCES[character]) {
+          result += SIMPLE_ESCAPE_SEQUENCES[character];
+          character = input.charCodeAt(++position);
+
+        } else if (HEXADECIMAL_ESCAPE_SEQUENCES[character]) {
+          hexLength = HEXADECIMAL_ESCAPE_SEQUENCES[character];
+          hexResult = 0;
+
+          for (hexIndex = 1; hexIndex <= hexLength; hexIndex += 1) {
+            hexOffset = (hexLength - hexIndex) * 4;
+            character = input.charCodeAt(++position);
+
+            if (CHAR_DIGIT_ZERO <= character && character <= CHAR_DIGIT_NINE) {
+              hexResult |= (character - CHAR_DIGIT_ZERO) << hexOffset;
+
+            } else if (CHAR_CAPITAL_A <= character && character <= CHAR_CAPITAL_F) {
+              hexResult |= (character - CHAR_CAPITAL_A + 10) << hexOffset;
+
+            } else if (CHAR_SMALL_A <= character && character <= CHAR_SMALL_F) {
+              hexResult |= (character - CHAR_SMALL_A + 10) << hexOffset;
+
+            } else {
+              throwError('expected hexadecimal character');
+            }
+          }
+
+          result += String.fromCharCode(hexResult);
+          character = input.charCodeAt(++position);
+
+        } else {
+          throwError('unknown escape sequence');
+        }
+
+        captureStart = captureEnd = position;
+
+      } else if (CHAR_LINE_FEED === character ||
+                 CHAR_CARRIAGE_RETURN === character) {
+        captureSegment(captureStart, captureEnd, true);
+        writeFoldedLines(skipSeparationSpace(false, nodeIndent));
+        captureStart = captureEnd = position;
+        character = input.charCodeAt(position);
+
+      } else if (position === lineStart && testDocumentSeparator()) {
+        throwError('unexpected end of the document within a double quoted scalar');
+
+      } else {
+        character = input.charCodeAt(++position);
+        captureEnd = position;
+      }
+    }
+
+    throwError('unexpected end of the stream within a double quoted scalar');
+  }
+
+  function readFlowCollection(nodeIndent) {
+    var readNext = true,
+        _line,
+        _tag     = tag,
+        _result,
+        following,
+        terminator,
+        isPair,
+        isExplicitPair,
+        isMapping,
+        keyNode,
+        keyTag,
+        valueNode;
+
+    switch (character) {
+    case CHAR_LEFT_SQUARE_BRACKET:
+      terminator = CHAR_RIGHT_SQUARE_BRACKET;
+      isMapping = false;
+      _result = [];
+      break;
+
+    case CHAR_LEFT_CURLY_BRACKET:
+      terminator = CHAR_RIGHT_CURLY_BRACKET;
+      isMapping = true;
+      _result = {};
+      break;
+
+    default:
+      return false;
+    }
+
+    if (null !== anchor) {
+      anchorMap[anchor] = _result;
+    }
+
+    character = input.charCodeAt(++position);
+
+    while (position < length) {
+      skipSeparationSpace(true, nodeIndent);
+
+      if (character === terminator) {
+        character = input.charCodeAt(++position);
+        tag = _tag;
+        kind = isMapping ? KIND_OBJECT : KIND_ARRAY;
+        result = _result;
+        return true;
+      } else if (!readNext) {
+        throwError('missed comma between flow collection entries');
+      }
+
+      keyTag = keyNode = valueNode = null;
+      isPair = isExplicitPair = false;
+
+      if (CHAR_QUESTION === character) {
+        following = input.charCodeAt(position + 1);
+
+        if (CHAR_SPACE === following ||
+            CHAR_TAB === following ||
+            CHAR_LINE_FEED === following ||
+            CHAR_CARRIAGE_RETURN === following) {
+          isPair = isExplicitPair = true;
+          position += 1;
+          character = following;
+          skipSeparationSpace(true, nodeIndent);
+        }
+      }
+
+      _line = line;
+      composeNode(nodeIndent, CONTEXT_FLOW_IN, false, true);
+      keyTag = tag;
+      keyNode = result;
+
+      if ((isExplicitPair || line === _line) && CHAR_COLON === character) {
+        isPair = true;
+        character = input.charCodeAt(++position);
+        skipSeparationSpace(true, nodeIndent);
+        composeNode(nodeIndent, CONTEXT_FLOW_IN, false, true);
+        valueNode = result;
+      }
+
+      if (isMapping) {
+        storeMappingPair(_result, keyTag, keyNode, valueNode);
+      } else if (isPair) {
+        _result.push(storeMappingPair(null, keyTag, keyNode, valueNode));
+      } else {
+        _result.push(keyNode);
+      }
+
+      skipSeparationSpace(true, nodeIndent);
+
+      if (CHAR_COMMA === character) {
+        readNext = true;
+        character = input.charCodeAt(++position);
+      } else {
+        readNext = false;
+      }
+    }
+
+    throwError('unexpected end of the stream within a flow collection');
+  }
+
+  function readBlockScalar(nodeIndent) {
+    var captureStart,
+        folding,
+        chomping       = CHOMPING_CLIP,
+        detectedIndent = false,
+        textIndent     = nodeIndent,
+        emptyLines     = -1;
+
+    switch (character) {
+    case CHAR_VERTICAL_LINE:
+      folding = false;
+      break;
+
+    case CHAR_GREATER_THAN:
+      folding = true;
+      break;
+
+    default:
+      return false;
+    }
+
+    kind = KIND_STRING;
+    result = '';
+
+    while (position < length) {
+      character = input.charCodeAt(++position);
+
+      if (CHAR_PLUS === character || CHAR_MINUS === character) {
+        if (CHOMPING_CLIP === chomping) {
+          chomping = (CHAR_PLUS === character) ? CHOMPING_KEEP : CHOMPING_STRIP;
+        } else {
+          throwError('repeat of a chomping mode identifier');
+        }
+
+      } else if (CHAR_DIGIT_ZERO <= character && character <= CHAR_DIGIT_NINE) {
+        if (CHAR_DIGIT_ZERO === character) {
+          throwError('bad explicit indentation width of a block scalar; it cannot be less than one');
+        } else if (!detectedIndent) {
+          textIndent = nodeIndent + (character - CHAR_DIGIT_ONE);
+          detectedIndent = true;
+        } else {
+          throwError('repeat of an indentation width identifier');
+        }
+
+      } else {
+        break;
+      }
+    }
+
+    if (CHAR_SPACE === character || CHAR_TAB === character) {
+      do { character = input.charCodeAt(++position); }
+      while (CHAR_SPACE === character || CHAR_TAB === character);
+
+      if (CHAR_SHARP === character) {
+        do { character = input.charCodeAt(++position); }
+        while (position < length &&
+               CHAR_LINE_FEED !== character &&
+               CHAR_CARRIAGE_RETURN !== character);
+      }
+    }
+
+    while (position < length) {
+      readLineBreak();
+      lineIndent = 0;
+
+      while ((!detectedIndent || lineIndent < textIndent) &&
+             (CHAR_SPACE === character)) {
+        lineIndent += 1;
+        character = input.charCodeAt(++position);
+      }
+
+      if (!detectedIndent && lineIndent > textIndent) {
+        textIndent = lineIndent;
+      }
+
+      if (CHAR_LINE_FEED === character || CHAR_CARRIAGE_RETURN === character) {
+        emptyLines += 1;
+        continue;
+      }
+
+      // End of the scalar. Perform the chomping.
+      if (lineIndent < textIndent) {
+        if (CHOMPING_KEEP === chomping) {
+          result += common.repeat('\n', emptyLines + 1);
+        } else if (CHOMPING_CLIP === chomping) {
+          result += '\n';
+        }
+        break;
+      }
+
+      detectedIndent = true;
+
+      if (folding) {
+        if (CHAR_SPACE === character || CHAR_TAB === character) {
+          result += common.repeat('\n', emptyLines + 1);
+          emptyLines = 1;
+        } else if (0 === emptyLines) {
+          result += ' ';
+          emptyLines = 0;
+        } else {
+          result += common.repeat('\n', emptyLines);
+          emptyLines = 0;
+        }
+      } else {
+        result += common.repeat('\n', emptyLines + 1);
+        emptyLines = 0;
+      }
+
+      captureStart = position;
+
+      do { character = input.charCodeAt(++position); }
+      while (position < length &&
+             CHAR_LINE_FEED !== character &&
+             CHAR_CARRIAGE_RETURN !== character);
+
+      captureSegment(captureStart, position, false);
+    }
+
+    return true;
+  }
+
+  function readBlockSequence(nodeIndent) {
+    var _line,
+        _tag      = tag,
+        _result   = [],
+        following,
+        detected  = false;
+
+    if (null !== anchor) {
+      anchorMap[anchor] = _result;
+    }
+
+    while (position < length) {
+      if (CHAR_MINUS !== character) {
+        break;
+      }
+
+      following = input.charCodeAt(position + 1);
+
+      if (CHAR_SPACE           !== following &&
+          CHAR_TAB             !== following &&
+          CHAR_LINE_FEED       !== following &&
+          CHAR_CARRIAGE_RETURN !== following) {
+        break;
+      }
+
+      detected = true;
+      position += 1;
+      character = following;
+
+      if (skipSeparationSpace(true, -1)) {
+        if (lineIndent <= nodeIndent) {
+          _result.push(null);
+          continue;
+        }
+      }
+
+      _line = line;
+      composeNode(nodeIndent, CONTEXT_BLOCK_IN, false, true);
+      _result.push(result);
+      skipSeparationSpace(true, -1);
+
+      if ((line === _line || lineIndent > nodeIndent) && position < length) {
+        throwError('bad indentation of a sequence entry');
+      } else if (lineIndent < nodeIndent) {
+        break;
+      }
+    }
+
+    if (detected) {
+      tag = _tag;
+      kind = KIND_ARRAY;
+      result = _result;
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  function readBlockMapping(nodeIndent) {
+    var following,
+        allowCompact,
+        _line,
+        _tag          = tag,
+        _result       = {},
+        keyTag        = null,
+        keyNode       = null,
+        valueNode     = null,
+        atExplicitKey = false,
+        detected      = false;
+
+    if (null !== anchor) {
+      anchorMap[anchor] = _result;
+    }
+
+    while (position < length) {
+      following = input.charCodeAt(position + 1);
+      _line = line; // Save the current line.
+
+      if ((CHAR_QUESTION        === character ||
+           CHAR_COLON           === character) &&
+          (CHAR_SPACE           === following ||
+           CHAR_TAB             === following ||
+           CHAR_LINE_FEED       === following ||
+           CHAR_CARRIAGE_RETURN === following)) {
+
+        if (CHAR_QUESTION === character) {
+          if (atExplicitKey) {
+            storeMappingPair(_result, keyTag, keyNode, null);
+            keyTag = keyNode = valueNode = null;
+          }
+
+          detected = true;
+          atExplicitKey = true;
+          allowCompact = true;
+
+        } else if (atExplicitKey) {
+          // i.e. CHAR_COLON === character after the explicit key.
+          atExplicitKey = false;
+          allowCompact = true;
+
+        } else {
+          throwError('incomplete explicit mapping pair; a key node is missed');
+        }
+
+        position += 1;
+        character = following;
+
+      } else if (composeNode(nodeIndent, CONTEXT_FLOW_OUT, false, true)) {
+        if (line === _line) {
+          // TODO: Remove this cycle when the flow readers will consume
+          // trailing whitespaces like the block readers.
+          while (CHAR_SPACE === character ||
+                 CHAR_TAB === character) {
+            character = input.charCodeAt(++position);
+          }
+
+          if (CHAR_COLON === character) {
+            character = input.charCodeAt(++position);
+
+            if (CHAR_SPACE           !== character &&
+                CHAR_TAB             !== character &&
+                CHAR_LINE_FEED       !== character &&
+                CHAR_CARRIAGE_RETURN !== character) {
+              throwError('a whitespace character is expected after the key-value separator within a block mapping');
+            }
+
+            if (atExplicitKey) {
+              storeMappingPair(_result, keyTag, keyNode, null);
+              keyTag = keyNode = valueNode = null;
+            }
+
+            detected = true;
+            atExplicitKey = false;
+            allowCompact = false;
+            keyTag = tag;
+            keyNode = result;
+
+          } else if (detected) {
+            throwError('can not read an implicit mapping pair; a colon is missed');
+
+          } else {
+            tag = _tag;
+            return true; // Keep the result of `composeNode`.
+          }
+
+        } else if (detected) {
+          throwError('can not read a block mapping entry; a multiline key may not be an implicit key');
+
+        } else {
+          tag = _tag;
+          return true; // Keep the result of `composeNode`.
+        }
+
+      } else {
+        break;
+      }
+
+      if (line === _line || lineIndent > nodeIndent) {
+        if (composeNode(nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) {
+          if (atExplicitKey) {
+            keyNode = result;
+          } else {
+            valueNode = result;
+          }
+        }
+
+        if (!atExplicitKey) {
+          storeMappingPair(_result, keyTag, keyNode, valueNode);
+          keyTag = keyNode = valueNode = null;
+        }
+
+        // TODO: It is needed only for flow node readers. It should be removed
+        // when the flow readers will consume trailing whitespaces as well as
+        // the block readers.
+        skipSeparationSpace(true, -1);
+      }
+
+      if (lineIndent > nodeIndent && position < length) {
+        throwError('bad indentation of a mapping entry');
+      } else if (lineIndent < nodeIndent) {
+        break;
+      }
+    }
+
+    if (atExplicitKey) {
+      storeMappingPair(_result, keyTag, keyNode, null);
+    }
+
+    if (detected) {
+      tag = _tag;
+      kind = KIND_OBJECT;
+      result = _result;
+    }
+
+    return detected;
+  }
+
+  function readTagProperty() {
+    var _position,
+        isVerbatim = false,
+        isNamed    = false,
+        tagHandle,
+        tagName;
+
+    if (CHAR_EXCLAMATION !== character) {
+      return false;
+    }
+
+    if (null !== tag) {
+      throwError('duplication of a tag property');
+    }
+
+    character = input.charCodeAt(++position);
+
+    if (CHAR_LESS_THAN === character) {
+      isVerbatim = true;
+      character = input.charCodeAt(++position);
+
+    } else if (CHAR_EXCLAMATION === character) {
+      isNamed = true;
+      tagHandle = '!!';
+      character = input.charCodeAt(++position);
+
+    } else {
+      tagHandle = '!';
+    }
+
+    _position = position;
+
+    if (isVerbatim) {
+      do { character = input.charCodeAt(++position); }
+      while (position < length && CHAR_GREATER_THAN !== character);
+
+      if (position < length) {
+        tagName = input.slice(_position, position);
+        character = input.charCodeAt(++position);
+      } else {
+        throwError('unexpected end of the stream within a verbatim tag');
+      }
+    } else {
+      while (position < length &&
+             CHAR_SPACE           !== character &&
+             CHAR_TAB             !== character &&
+             CHAR_LINE_FEED       !== character &&
+             CHAR_CARRIAGE_RETURN !== character) {
+
+        if (CHAR_EXCLAMATION === character) {
+          if (!isNamed) {
+            tagHandle = input.slice(_position - 1, position + 1);
+
+            if (validate && !PATTERN_TAG_HANDLE.test(tagHandle)) {
+              throwError('named tag handle cannot contain such characters');
+            }
+
+            isNamed = true;
+            _position = position + 1;
+          } else {
+            throwError('tag suffix cannot contain exclamation marks');
+          }
+        }
+
+        character = input.charCodeAt(++position);
+      }
+
+      tagName = input.slice(_position, position);
+
+      if (validate && PATTERN_FLOW_INDICATORS.test(tagName)) {
+        throwError('tag suffix cannot contain flow indicator characters');
+      }
+    }
+
+    if (validate && tagName && !PATTERN_TAG_URI.test(tagName)) {
+      throwError('tag name cannot contain such characters: ' + tagName);
+    }
+
+    if (isVerbatim) {
+      tag = tagName;
+
+    } else if (_hasOwnProperty.call(tagMap, tagHandle)) {
+      tag = tagMap[tagHandle] + tagName;
+
+    } else if ('!' === tagHandle) {
+      tag = '!' + tagName;
+
+    } else if ('!!' === tagHandle) {
+      tag = 'tag:yaml.org,2002:' + tagName;
+
+    } else {
+      throwError('undeclared tag handle "' + tagHandle + '"');
+    }
+
+    return true;
+  }
+
+  function readAnchorProperty() {
+    var _position;
+
+    if (CHAR_AMPERSAND !== character) {
+      return false;
+    }
+
+    if (null !== anchor) {
+      throwError('duplication of an anchor property');
+    }
+
+    character = input.charCodeAt(++position);
+    _position = position;
+
+    while (position < length &&
+           CHAR_SPACE                !== character &&
+           CHAR_TAB                  !== character &&
+           CHAR_LINE_FEED            !== character &&
+           CHAR_CARRIAGE_RETURN      !== character &&
+           CHAR_COMMA                !== character &&
+           CHAR_LEFT_SQUARE_BRACKET  !== character &&
+           CHAR_RIGHT_SQUARE_BRACKET !== character &&
+           CHAR_LEFT_CURLY_BRACKET   !== character &&
+           CHAR_RIGHT_CURLY_BRACKET  !== character) {
+      character = input.charCodeAt(++position);
+    }
+
+    if (position === _position) {
+      throwError('name of an anchor node must contain at least one character');
+    }
+
+    anchor = input.slice(_position, position);
+    return true;
+  }
+
+  function readAlias() {
+    var _position, alias;
+
+    if (CHAR_ASTERISK !== character) {
+      return false;
+    }
+
+    character = input.charCodeAt(++position);
+    _position = position;
+
+    while (position < length &&
+           CHAR_SPACE                !== character &&
+           CHAR_TAB                  !== character &&
+           CHAR_LINE_FEED            !== character &&
+           CHAR_CARRIAGE_RETURN      !== character &&
+           CHAR_COMMA                !== character &&
+           CHAR_LEFT_SQUARE_BRACKET  !== character &&
+           CHAR_RIGHT_SQUARE_BRACKET !== character &&
+           CHAR_LEFT_CURLY_BRACKET   !== character &&
+           CHAR_RIGHT_CURLY_BRACKET  !== character) {
+      character = input.charCodeAt(++position);
+    }
+
+    if (position === _position) {
+      throwError('name of an alias node must contain at least one character');
+    }
+
+    alias = input.slice(_position, position);
+
+    if (!anchorMap.hasOwnProperty(alias)) {
+      throwError('unidentified alias "' + alias + '"');
+    }
+
+    result = anchorMap[alias];
+    skipSeparationSpace(true, -1);
+    return true;
+  }
+
+  function composeNode(parentIndent, nodeContext, allowToSeek, allowCompact) {
+    var allowBlockStyles,
+        allowBlockScalars,
+        allowBlockCollections,
+        atNewLine  = false,
+        isIndented = true,
+        hasContent = false,
+        typeIndex,
+        typeQuantity,
+        type,
+        typeLoader,
+        flowIndent,
+        blockIndent,
+        _result;
+
+    tag    = null;
+    anchor = null;
+    kind   = null;
+    result = null;
+
+    allowBlockStyles = allowBlockScalars = allowBlockCollections =
+      CONTEXT_BLOCK_OUT === nodeContext ||
+      CONTEXT_BLOCK_IN  === nodeContext;
+
+    if (allowToSeek) {
+      if (skipSeparationSpace(true, -1)) {
+        atNewLine = true;
+
+        if (lineIndent === parentIndent) {
+          isIndented = false;
+
+        } else if (lineIndent > parentIndent) {
+          isIndented = true;
+
+        } else {
+          return false;
+        }
+      }
+    }
+
+    if (isIndented) {
+      while (readTagProperty() || readAnchorProperty()) {
+        if (skipSeparationSpace(true, -1)) {
+          atNewLine = true;
+
+          if (lineIndent > parentIndent) {
+            isIndented = true;
+            allowBlockCollections = allowBlockStyles;
+
+          } else if (lineIndent === parentIndent) {
+            isIndented = false;
+            allowBlockCollections = allowBlockStyles;
+
+          } else {
+            return true;
+          }
+        } else {
+          allowBlockCollections = false;
+        }
+      }
+    }
+
+    if (allowBlockCollections) {
+      allowBlockCollections = atNewLine || allowCompact;
+    }
+
+    if (isIndented || CONTEXT_BLOCK_OUT === nodeContext) {
+      if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) {
+        flowIndent = parentIndent;
+      } else {
+        flowIndent = parentIndent + 1;
+      }
+
+      blockIndent = position - lineStart;
+
+      if (isIndented) {
+        if (allowBlockCollections &&
+            (readBlockSequence(blockIndent) ||
+             readBlockMapping(blockIndent)) ||
+            readFlowCollection(flowIndent)) {
+          hasContent = true;
+        } else {
+          if ((allowBlockScalars && readBlockScalar(flowIndent)) ||
+              readSingleQuotedScalar(flowIndent) ||
+              readDoubleQuotedScalar(flowIndent)) {
+            hasContent = true;
+
+          } else if (readAlias()) {
+            hasContent = true;
+
+            if (null !== tag || null !== anchor) {
+              throwError('alias node should not have any properties');
+            }
+
+          } else if (readPlainScalar(flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
+            hasContent = true;
+
+            if (null === tag) {
+              tag = '?';
+            }
+          }
+
+          if (null !== anchor) {
+            anchorMap[anchor] = result;
+          }
+        }
+      } else {
+        hasContent = allowBlockCollections && readBlockSequence(blockIndent);
+      }
+    }
+
+    if (null !== tag && '!' !== tag) {
+      if ('?' === tag) {
+        if (resolve) {
+          for (typeIndex = 0, typeQuantity = implicitTypes.length;
+               typeIndex < typeQuantity;
+               typeIndex += 1) {
+            type = implicitTypes[typeIndex];
+
+            // Implicit resolving is not allowed for non-scalar types, and '?'
+            // non-specific tag is only assigned to plain scalars. So, it isn't
+            // needed to check for 'kind' conformity.
+            _result = type.loader.resolver(result, false);
+
+            if (NIL !== _result) {
+              tag = type.tag;
+              result = _result;
+              break;
+            }
+          }
+        }
+      } else if (_hasOwnProperty.call(typeMap, tag)) {
+        typeLoader = typeMap[tag].loader;
+
+        if (null !== result && typeLoader.kind !== kind) {
+          throwError('unacceptable node kind for !<' + tag + '> tag; it should be "' + typeLoader.kind + '", not "' + kind + '"');
+        }
+
+        if (typeLoader.resolver) {
+          _result = typeLoader.resolver(result, true);
+
+          if (NIL !== _result) {
+            result = _result;
+          } else {
+            throwError('cannot resolve a node with !<' + tag + '> explicit tag');
+          }
+        }
+      } else {
+        throwWarning('unknown tag !<' + tag + '>');
+      }
+    }
+
+    return null !== tag || null !== anchor || hasContent;
+  }
+
+  function readDocument() {
+    var documentStart = position,
+        _position,
+        directiveName,
+        directiveArgs,
+        hasDirectives = false;
+
+    version = null;
+    checkLineBreaks = legacy;
+    tagMap = {};
+    anchorMap = {};
+
+    while (position < length) {
+      skipSeparationSpace(true, -1);
+
+      if (lineIndent > 0 || CHAR_PERCENT !== character) {
+        break;
+      }
+
+      hasDirectives = true;
+      character = input.charCodeAt(++position);
+      _position = position;
+
+      while (position < length &&
+             CHAR_SPACE           !== character &&
+             CHAR_TAB             !== character &&
+             CHAR_LINE_FEED       !== character &&
+             CHAR_CARRIAGE_RETURN !== character) {
+        character = input.charCodeAt(++position);
+      }
+
+      directiveName = input.slice(_position, position);
+      directiveArgs = [];
+
+      if (directiveName.length < 1) {
+        throwError('directive name must not be less than one character in length');
+      }
+
+      while (position < length) {
+        while (CHAR_SPACE === character || CHAR_TAB === character) {
+          character = input.charCodeAt(++position);
+        }
+
+        if (CHAR_SHARP === character) {
+          do { character = input.charCodeAt(++position); }
+          while (position < length &&
+                 CHAR_LINE_FEED !== character &&
+                 CHAR_CARRIAGE_RETURN !== character);
+          break;
+        }
+
+        if (CHAR_LINE_FEED === character || CHAR_CARRIAGE_RETURN === character) {
+          break;
+        }
+
+        _position = position;
+
+        while (position < length &&
+               CHAR_SPACE           !== character &&
+               CHAR_TAB             !== character &&
+               CHAR_LINE_FEED       !== character &&
+               CHAR_CARRIAGE_RETURN !== character) {
+          character = input.charCodeAt(++position);
+        }
+
+        directiveArgs.push(input.slice(_position, position));
+      }
+
+      if (position < length) {
+        readLineBreak();
+      }
+
+      if (_hasOwnProperty.call(directiveHandlers, directiveName)) {
+        directiveHandlers[directiveName](directiveName, directiveArgs);
+      } else {
+        throwWarning('unknown document directive "' + directiveName + '"');
+      }
+    }
+
+    skipSeparationSpace(true, -1);
+
+    if (0 === lineIndent &&
+        CHAR_MINUS === character &&
+        CHAR_MINUS === input.charCodeAt(position + 1) &&
+        CHAR_MINUS === input.charCodeAt(position + 2)) {
+      position += 3;
+      character = input.charCodeAt(position);
+      skipSeparationSpace(true, -1);
+
+    } else if (hasDirectives) {
+      throwError('directives end mark is expected');
+    }
+
+    composeNode(lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
+    skipSeparationSpace(true, -1);
+
+    if (validate && checkLineBreaks &&
+        PATTERN_NON_ASCII_LINE_BREAKS.test(input.slice(documentStart, position))) {
+      throwWarning('non-ASCII line breaks are interpreted as content');
+    }
+
+    output(result);
+
+    if (position === lineStart && testDocumentSeparator()) {
+      if (CHAR_DOT === character) {
+        position += 3;
+        character = input.charCodeAt(position);
+        skipSeparationSpace(true, -1);
+      }
+      return;
+    }
+
+    if (position < length) {
+      throwError('end of the stream or a document separator is expected');
+    } else {
+      return;
+    }
+  }
+
+  if (validate && PATTERN_NON_PRINTABLE.test(input)) {
+    throwError('the stream contains non-printable characters');
+  }
+
+  while (CHAR_SPACE === character) {
+    lineIndent += 1;
+    character = input.charCodeAt(++position);
+  }
+
+  while (position < length) {
+    readDocument();
+  }
+}
+
+
+function load(input, options) {
+  var result = null, received = false;
+
+  function callback(data) {
+    if (!received) {
+      result = data;
+      received = true;
+    } else {
+      throw new YAMLException('expected a single document in the stream, but found more');
+    }
+  }
+
+  loadAll(input, callback, options);
+
+  return result;
+}
+
+
+function safeLoadAll(input, output, options) {
+  loadAll(input, output, common.extend({ schema: SAFE_SCHEMA }, options));
+}
+
+
+function safeLoad(input, options) {
+  return load(input, common.extend({ schema: SAFE_SCHEMA }, options));
+}
+
+
+module.exports.loadAll     = loadAll;
+module.exports.load        = load;
+module.exports.safeLoadAll = safeLoadAll;
+module.exports.safeLoad    = safeLoad;