get strValue() {
      if (!this.valueRange || !this.context) return null;
      const errors$1 = [];
      const {
        start,
        end
      } = this.valueRange;
      const {
        indent,
        src
      } = this.context;
      if (src[end - 1] !== '"') errors$1.push(new errors.YAMLSyntaxError(this, 'Missing closing "quote')); // Using String#replace is too painful with escaped newlines preceded by
      // escaped backslashes; also, this should be faster.

      let str = '';

      for (let i = start + 1; i < end - 1; ++i) {
        const ch = src[i];

        if (ch === '\n') {
          if (_Node.default.atDocumentBoundary(src, i + 1)) errors$1.push(new errors.YAMLSemanticError(this, 'Document boundary indicators are not allowed within string values'));

          const {
            fold,
            offset,
            error
          } = _Node.default.foldNewline(src, i, indent);

          str += fold;
          i = offset;
          if (error) errors$1.push(new errors.YAMLSemanticError(this, 'Multi-line double-quoted string needs to be sufficiently indented'));
        } else if (ch === '\\') {
          i += 1;

          switch (src[i]) {
            case '0':
              str += '\0';
              break;
            // null character

            case 'a':
              str += '\x07';
              break;
            // bell character

            case 'b':
              str += '\b';
              break;
            // backspace

            case 'e':
              str += '\x1b';
              break;
            // escape character

            case 'f':
              str += '\f';
              break;
            // form feed

            case 'n':
              str += '\n';
              break;
            // line feed

            case 'r':
              str += '\r';
              break;
            // carriage return

            case 't':
              str += '\t';
              break;
            // horizontal tab

            case 'v':
              str += '\v';
              break;
            // vertical tab

            case 'N':
              str += '\u0085';
              break;
            // Unicode next line

            case '_':
              str += '\u00a0';
              break;
            // Unicode non-breaking space

            case 'L':
              str += '\u2028';
              break;
            // Unicode line separator

            case 'P':
              str += '\u2029';
              break;
            // Unicode paragraph separator

            case ' ':
              str += ' ';
              break;

            case '"':
              str += '"';
              break;

            case '/':
              str += '/';
              break;

            case '\\':
              str += '\\';
              break;

            case '\t':
              str += '\t';
              break;

            case 'x':
              str += this.parseCharCode(i + 1, 2, errors$1);
              i += 2;
              break;

            case 'u':
              str += this.parseCharCode(i + 1, 4, errors$1);
              i += 4;
              break;

            case 'U':
              str += this.parseCharCode(i + 1, 8, errors$1);
              i += 8;
              break;

            case '\n':
              // skip escaped newlines, but still trim the following line
              while (src[i + 1] === ' ' || src[i + 1] === '\t') i += 1;

              break;

            default:
              errors$1.push(new errors.YAMLSyntaxError(this, `Invalid escape sequence ${src.substr(i - 1, 2)}`));
              str += '\\' + src[i];
          }
        } else if (ch === ' ' || ch === '\t') {
          // trim trailing whitespace
          const wsStart = i;
          let next = src[i + 1];

          while (next === ' ' || next === '\t') {
            i += 1;
            next = src[i + 1];
          }

          if (next !== '\n') str += i > wsStart ? src.slice(wsStart, i + 1) : ch;
        } else {
          str += ch;
        }
      }

      return errors$1.length > 0 ? {
        errors: errors$1,
        str
      } : str;
    }
@returns {string | { str: string, errors: YAMLSyntaxError[] }}