yaml 2.0.0-10 → 2.0.0-5

package/browser/dist/stringify/stringifyString.js

@@ -118,50 +118,34 @@ function doubleQuotedString(value, ctx) {
         : foldFlowLines(str, indent, FOLD_QUOTED, getFoldOptions(ctx));
 }
 function singleQuotedString(value, ctx) {
-    if (ctx.options.singleQuote === false ||
-        (ctx.implicitKey && value.includes('\n')) ||
-        /[ \t]\n|\n[ \t]/.test(value) // single quoted string can't have leading or trailing whitespace around newline
-    )
-        return doubleQuotedString(value, ctx);
+    if (ctx.implicitKey) {
+        if (/\n/.test(value))
+            return doubleQuotedString(value, ctx);
+    }
+    else {
+        // single quoted string can't have leading or trailing whitespace around newline
+        if (/[ \t]\n|\n[ \t]/.test(value))
+            return doubleQuotedString(value, ctx);
+    }
     const indent = ctx.indent || (containsDocumentMarker(value) ? '  ' : '');
     const res = "'" + value.replace(/'/g, "''").replace(/\n+/g, `$&\n${indent}`) + "'";
     return ctx.implicitKey
         ? res
         : foldFlowLines(res, indent, FOLD_FLOW, getFoldOptions(ctx));
 }
-function quotedString(value, ctx) {
-    const { singleQuote } = ctx.options;
-    let qs;
-    if (singleQuote === false)
-        qs = doubleQuotedString;
-    else {
-        const hasDouble = value.includes('"');
-        const hasSingle = value.includes("'");
-        if (hasDouble && !hasSingle)
-            qs = singleQuotedString;
-        else if (hasSingle && !hasDouble)
-            qs = doubleQuotedString;
-        else
-            qs = singleQuote ? singleQuotedString : doubleQuotedString;
-    }
-    return qs(value, ctx);
-}
 function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
-    const { blockQuote, commentString, lineWidth } = ctx.options;
     // 1. Block can't end in whitespace unless the last line is non-empty.
     // 2. Strings consisting of only whitespace are best rendered explicitly.
-    if (!blockQuote || /\n[\t ]+$/.test(value) || /^\s*$/.test(value)) {
-        return quotedString(value, ctx);
+    if (/\n[\t ]+$/.test(value) || /^\s*$/.test(value)) {
+        return doubleQuotedString(value, ctx);
     }
     const indent = ctx.indent ||
         (ctx.forceBlockIndent || containsDocumentMarker(value) ? '  ' : '');
-    const literal = blockQuote === 'literal'
-        ? true
-        : blockQuote === 'folded' || type === Scalar.BLOCK_FOLDED
-            ? false
-            : type === Scalar.BLOCK_LITERAL
-                ? true
-                : !lineLengthOverLimit(value, lineWidth, indent.length);
+    const literal = type === Scalar.BLOCK_FOLDED
+        ? false
+        : type === Scalar.BLOCK_LITERAL
+            ? true
+            : !lineLengthOverLimit(value, ctx.options.lineWidth, indent.length);
     if (!value)
         return literal ? '|\n' : '>\n';
     // determine chomping from whitespace at value end
@@ -212,7 +196,7 @@ function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
     const indentSize = indent ? '2' : '1'; // root is at -1
     let header = (literal ? '|' : '>') + (startWithSpace ? indentSize : '') + chomp;
     if (comment) {
-        header += ' ' + commentString(comment.replace(/ ?[\r\n]+/g, ' '));
+        header += ' #' + comment.replace(/ ?[\r\n]+/g, ' ');
         if (onComment)
             onComment();
     }
@@ -229,14 +213,30 @@ function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
     return `${header}\n${indent}${body}`;
 }
 function plainString(item, ctx, onComment, onChompKeep) {
+    var _a;
     const { type, value } = item;
     const { actualString, implicitKey, indent, inFlow } = ctx;
     if ((implicitKey && /[\n[\]{},]/.test(value)) ||
         (inFlow && /[[\]{},]/.test(value))) {
-        return quotedString(value, ctx);
+        return doubleQuotedString(value, ctx);
     }
     if (!value ||
         /^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(value)) {
+        const hasDouble = value.indexOf('"') !== -1;
+        const hasSingle = value.indexOf("'") !== -1;
+        let quotedString;
+        if (hasDouble && !hasSingle) {
+            quotedString = singleQuotedString;
+        }
+        else if (hasSingle && !hasDouble) {
+            quotedString = doubleQuotedString;
+        }
+        else if (ctx.options.singleQuote) {
+            quotedString = singleQuotedString;
+        }
+        else {
+            quotedString = doubleQuotedString;
+        }
         // not allowed:
         // - empty string, '-' or '?'
         // - start with an indicator character (except [?:-]) or /[?-] /
@@ -263,10 +263,12 @@ function plainString(item, ctx, onComment, onChompKeep) {
     // booleans get parsed with those types in v1.2 (e.g. '42', 'true' & '0.9e-3'),
     // and others in v1.1.
     if (actualString) {
-        const test = (tag) => { var _a; return tag.default && tag.tag !== 'tag:yaml.org,2002:str' && ((_a = tag.test) === null || _a === void 0 ? void 0 : _a.test(str)); };
-        const { compat, tags } = ctx.doc.schema;
-        if (tags.some(test) || (compat === null || compat === void 0 ? void 0 : compat.some(test)))
-            return quotedString(value, ctx);
+        for (const tag of ctx.doc.schema.tags) {
+            if (tag.default &&
+                tag.tag !== 'tag:yaml.org,2002:str' &&
+                ((_a = tag.test) === null || _a === void 0 ? void 0 : _a.test(str)))
+                return doubleQuotedString(value, ctx);
+        }
     }
     return implicitKey
         ? str
@@ -288,7 +290,7 @@ function stringifyString(item, ctx, onComment, onChompKeep) {
             case Scalar.BLOCK_FOLDED:
             case Scalar.BLOCK_LITERAL:
                 return implicitKey || inFlow
-                    ? quotedString(ss.value, ctx) // blocks are not valid inside flow containers
+                    ? doubleQuotedString(ss.value, ctx) // blocks are not valid inside flow containers
                     : blockString(ss, ctx, onComment, onChompKeep);
             case Scalar.QUOTE_DOUBLE:
                 return doubleQuotedString(ss.value, ctx);

package/browser/dist/util.js

@@ -1,9 +1,6 @@
 export { debug, warn } from './log.js';
 export { findPair } from './nodes/YAMLMap.js';
 export { toJS } from './nodes/toJS.js';
-export { map as mapTag } from './schema/common/map.js';
-export { seq as seqTag } from './schema/common/seq.js';
-export { string as stringTag } from './schema/common/string.js';
 export { foldFlowLines } from './stringify/foldFlowLines.js';
 export { stringifyNumber } from './stringify/stringifyNumber.js';
 export { stringifyString } from './stringify/stringifyString.js';

package/dist/compose/compose-doc.js

@@ -9,14 +9,13 @@ function composeDoc(options, directives, { offset, start, value, end }, onError)
     const opts = Object.assign({ directives }, options);
     const doc = new Document.Document(undefined, opts);
     const ctx = {
-        atRoot: true,
         directives: doc.directives,
         options: doc.options,
         schema: doc.schema
     };
     const props = resolveProps.resolveProps(start, {
+        ctx,
         indicator: 'doc-start',
-        next: value || (end === null || end === void 0 ? void 0 : end[0]),
         offset,
         onError,
         startOnNewline: true

package/dist/compose/compose-node.d.ts

@@ -5,7 +5,6 @@ import type { SourceToken, Token } from '../parse/cst.js';
 import type { Schema } from '../schema/Schema.js';
 import type { ComposeErrorHandler } from './composer.js';
 export interface ComposeContext {
-    atRoot: boolean;
     directives: Directives;
     options: Readonly<Required<Omit<ParseOptions, 'lineCounter'>>>;
     schema: Readonly<Schema>;

package/dist/compose/compose-node.js

@@ -35,8 +35,6 @@ function composeNode(ctx, token, props, onError) {
             console.log(token);
             throw new Error(`Unsupporten token type: ${token.type}`);
     }
-    if (anchor && node.anchor === '')
-        onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string');
     if (spaceBefore)
         node.spaceBefore = true;
     if (comment) {
@@ -45,8 +43,6 @@ function composeNode(ctx, token, props, onError) {
         else
             node.commentBefore = comment;
     }
-    if (ctx.options.keepSourceTokens)
-        node.srcToken = token;
     return node;
 }
 function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anchor, tag }, onError) {
@@ -57,11 +53,8 @@ function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anch
         source: ''
     };
     const node = composeScalar.composeScalar(ctx, token, tag, onError);
-    if (anchor) {
+    if (anchor)
         node.anchor = anchor.source.substring(1);
-        if (node.anchor === '')
-            onError(anchor, 'BAD_ALIAS', 'Anchor cannot be an empty string');
-    }
     if (spaceBefore)
         node.spaceBefore = true;
     if (comment)
@@ -70,8 +63,6 @@ function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anch
 }
 function composeAlias({ options }, { offset, source, end }, onError) {
     const alias = new Alias.Alias(source.substring(1));
-    if (alias.source === '')
-        onError(offset, 'BAD_ALIAS', 'Alias cannot be an empty string');
     const valueEnd = offset + source.length;
     const re = resolveEnd.resolveEnd(end, valueEnd, options.strict, onError);
     alias.range = [offset, valueEnd, re.offset];

package/dist/compose/compose-scalar.js

@@ -14,17 +14,14 @@ function composeScalar(ctx, token, tagToken, onError) {
         : null;
     const tag = tagToken && tagName
         ? findScalarTagByName(ctx.schema, value, tagName, tagToken, onError)
-        : token.type === 'scalar'
-            ? findScalarTagByTest(ctx, value, token, onError)
-            : ctx.schema[Node.SCALAR];
+        : findScalarTagByTest(ctx.schema, value, token.type === 'scalar');
     let scalar;
     try {
         const res = tag.resolve(value, msg => onError(tagToken || token, 'TAG_RESOLVE_FAILED', msg), ctx.options);
         scalar = Node.isScalar(res) ? res : new Scalar.Scalar(res);
     }
     catch (error) {
-        const msg = error instanceof Error ? error.message : String(error);
-        onError(tagToken || token, 'TAG_RESOLVE_FAILED', msg);
+        onError(tagToken || token, 'TAG_RESOLVE_FAILED', error.message);
         scalar = new Scalar.Scalar(value);
     }
     scalar.range = range;
@@ -65,19 +62,15 @@ function findScalarTagByName(schema, value, tagName, tagToken, onError) {
     onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, tagName !== 'tag:yaml.org,2002:str');
     return schema[Node.SCALAR];
 }
-function findScalarTagByTest({ directives, schema }, value, token, onError) {
-    const tag = schema.tags.find(tag => { var _a; return tag.default && ((_a = tag.test) === null || _a === void 0 ? void 0 : _a.test(value)); }) || schema[Node.SCALAR];
-    if (schema.compat) {
-        const compat = schema.compat.find(tag => { var _a; return tag.default && ((_a = tag.test) === null || _a === void 0 ? void 0 : _a.test(value)); }) ||
-            schema[Node.SCALAR];
-        if (tag.tag !== compat.tag) {
-            const ts = directives.tagString(tag.tag);
-            const cs = directives.tagString(compat.tag);
-            const msg = `Value may be parsed as either ${ts} or ${cs}`;
-            onError(token, 'TAG_RESOLVE_FAILED', msg, true);
+function findScalarTagByTest(schema, value, apply) {
+    var _a;
+    if (apply) {
+        for (const tag of schema.tags) {
+            if (tag.default && ((_a = tag.test) === null || _a === void 0 ? void 0 : _a.test(value)))
+                return tag;
         }
     }
-    return tag;
+    return schema[Node.SCALAR];
 }
 
 exports.composeScalar = composeScalar;

package/dist/compose/composer.js

@@ -17,7 +17,6 @@ function getErrorPos(src) {
     return [offset, offset + (typeof source === 'string' ? source.length : 1)];
 }
 function parsePrelude(prelude) {
-    var _a;
     let comment = '';
     let atComment = false;
     let afterEmptyLine = false;
@@ -27,12 +26,12 @@ function parsePrelude(prelude) {
             case '#':
                 comment +=
                     (comment === '' ? '' : afterEmptyLine ? '\n\n' : '\n') +
-                        (source.substring(1) || ' ');
+                        source.substring(1);
                 atComment = true;
                 afterEmptyLine = false;
                 break;
             case '%':
-                if (((_a = prelude[i + 1]) === null || _a === void 0 ? void 0 : _a[0]) !== '#')
+                if (prelude[i + 1][0] !== '#')
                     i += 1;
                 atComment = false;
                 break;

package/dist/compose/resolve-block-map.d.ts

@@ -1,6 +1,5 @@
-import type { ParsedNode } from '../nodes/Node.js';
 import { YAMLMap } from '../nodes/YAMLMap.js';
 import type { BlockMap } from '../parse/cst.js';
 import type { ComposeContext, ComposeNode } from './compose-node.js';
 import type { ComposeErrorHandler } from './composer.js';
-export declare function resolveBlockMap({ composeNode, composeEmptyNode }: ComposeNode, ctx: ComposeContext, bm: BlockMap, onError: ComposeErrorHandler): YAMLMap.Parsed<ParsedNode, ParsedNode | null>;
+export declare function resolveBlockMap({ composeNode, composeEmptyNode }: ComposeNode, ctx: ComposeContext, bm: BlockMap, onError: ComposeErrorHandler): YAMLMap.Parsed<import("../index.js").ParsedNode, import("../index.js").ParsedNode | null>;

package/dist/compose/resolve-block-map.js

@@ -4,22 +4,17 @@ var Pair = require('../nodes/Pair.js');
 var YAMLMap = require('../nodes/YAMLMap.js');
 var resolveProps = require('./resolve-props.js');
 var utilContainsNewline = require('./util-contains-newline.js');
-var utilFlowIndentCheck = require('./util-flow-indent-check.js');
-var utilMapIncludes = require('./util-map-includes.js');
 
 const startColMsg = 'All mapping items must start at the same column';
 function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
     var _a;
     const map = new YAMLMap.YAMLMap(ctx.schema);
-    if (ctx.atRoot)
-        ctx.atRoot = false;
     let offset = bm.offset;
-    for (const collItem of bm.items) {
-        const { start, key, sep, value } = collItem;
+    for (const { start, key, sep, value } of bm.items) {
         // key properties
         const keyProps = resolveProps.resolveProps(start, {
+            ctx,
             indicator: 'explicit-key-ind',
-            next: key || (sep === null || sep === void 0 ? void 0 : sep[0]),
             offset,
             onError,
             startOnNewline: true
@@ -53,14 +48,10 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
         const keyNode = key
             ? composeNode(ctx, key, keyProps, onError)
             : composeEmptyNode(ctx, keyStart, start, null, keyProps, onError);
-        if (ctx.schema.compat)
-            utilFlowIndentCheck.flowIndentCheck(bm.indent, key, onError);
-        if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
-            onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique');
         // value properties
         const valueProps = resolveProps.resolveProps(sep || [], {
+            ctx,
             indicator: 'map-value-ind',
-            next: value,
             offset: keyNode.range[2],
             onError,
             startOnNewline: !key || key.type === 'block-scalar'
@@ -78,13 +69,8 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
             const valueNode = value
                 ? composeNode(ctx, value, valueProps, onError)
                 : composeEmptyNode(ctx, offset, sep, null, valueProps, onError);
-            if (ctx.schema.compat)
-                utilFlowIndentCheck.flowIndentCheck(bm.indent, value, onError);
             offset = valueNode.range[2];
-            const pair = new Pair.Pair(keyNode, valueNode);
-            if (ctx.options.keepSourceTokens)
-                pair.srcToken = collItem;
-            map.items.push(pair);
+            map.items.push(new Pair.Pair(keyNode, valueNode));
         }
         else {
             // key with no value
@@ -96,10 +82,7 @@ function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
                 else
                     keyNode.comment = valueProps.comment;
             }
-            const pair = new Pair.Pair(keyNode);
-            if (ctx.options.keepSourceTokens)
-                pair.srcToken = collItem;
-            map.items.push(pair);
+            map.items.push(new Pair.Pair(keyNode));
         }
     }
     map.range = [bm.offset, offset, offset];

package/dist/compose/resolve-block-scalar.js

@@ -20,7 +20,7 @@ function resolveBlockScalar(scalar, strict, onError) {
     }
     // shortcut for empty contents
     if (!scalar.source || chompStart === 0) {
-        const value = header.chomp === '+' ? '\n'.repeat(Math.max(0, lines.length - 1)) : '';
+        const value = header.chomp === '+' ? lines.map(line => line[0]).join('\n') : '';
         let end = start + header.length;
         if (scalar.source)
             end += scalar.source.length;
@@ -151,7 +151,7 @@ function parseBlockScalarHeader({ offset, props }, strict, onError) {
             case 'comment':
                 if (strict && !hasSpace) {
                     const message = 'Comments must be separated from other tokens by white space characters';
-                    onError(token, 'MISSING_CHAR', message);
+                    onError(token, 'COMMENT_SPACE', message);
                 }
                 length += token.source.length;
                 comment = token.source.substring(1);

package/dist/compose/resolve-block-seq.js

@@ -2,17 +2,14 @@
 
 var YAMLSeq = require('../nodes/YAMLSeq.js');
 var resolveProps = require('./resolve-props.js');
-var utilFlowIndentCheck = require('./util-flow-indent-check.js');
 
 function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError) {
     const seq = new YAMLSeq.YAMLSeq(ctx.schema);
-    if (ctx.atRoot)
-        ctx.atRoot = false;
     let offset = bs.offset;
     for (const { start, value } of bs.items) {
         const props = resolveProps.resolveProps(start, {
+            ctx,
             indicator: 'seq-item-ind',
-            next: value,
             offset,
             onError,
             startOnNewline: true
@@ -35,8 +32,6 @@ function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError) {
         const node = value
             ? composeNode(ctx, value, props, onError)
             : composeEmptyNode(ctx, offset, start, null, props, onError);
-        if (ctx.schema.compat)
-            utilFlowIndentCheck.flowIndentCheck(bs.indent, value, onError);
         offset = node.range[2];
         seq.items.push(node);
     }

package/dist/compose/resolve-end.js

@@ -13,8 +13,8 @@ function resolveEnd(end, offset, reqSpace, onError) {
                     break;
                 case 'comment': {
                     if (reqSpace && !hasSpace)
-                        onError(token, 'MISSING_CHAR', 'Comments must be separated from other tokens by white space characters');
-                    const cb = source.substring(1) || ' ';
+                        onError(token, 'COMMENT_SPACE', 'Comments must be separated from other tokens by white space characters');
+                    const cb = source.substring(1);
                     if (!comment)
                         comment = cb;
                     else

package/dist/compose/resolve-flow-collection.js

@@ -7,7 +7,6 @@ var YAMLSeq = require('../nodes/YAMLSeq.js');
 var resolveEnd = require('./resolve-end.js');
 var resolveProps = require('./resolve-props.js');
 var utilContainsNewline = require('./util-contains-newline.js');
-var utilMapIncludes = require('./util-map-includes.js');
 
 const blockMsg = 'Block collections are not allowed within flow collections';
 const isBlock = (token) => token && (token.type === 'block-map' || token.type === 'block-seq');
@@ -18,17 +17,13 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
         ? new YAMLMap.YAMLMap(ctx.schema)
         : new YAMLSeq.YAMLSeq(ctx.schema);
     coll.flow = true;
-    const atRoot = ctx.atRoot;
-    if (atRoot)
-        ctx.atRoot = false;
-    let offset = fc.offset + fc.start.source.length;
+    let offset = fc.offset;
     for (let i = 0; i < fc.items.length; ++i) {
-        const collItem = fc.items[i];
-        const { start, key, sep, value } = collItem;
+        const { start, key, sep, value } = fc.items[i];
         const props = resolveProps.resolveProps(start, {
+            ctx,
             flow: fcName,
             indicator: 'explicit-key-ind',
-            next: key || (sep === null || sep === void 0 ? void 0 : sep[0]),
             offset,
             onError,
             startOnNewline: false
@@ -45,7 +40,6 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                     else
                         coll.comment = props.comment;
                 }
-                offset = props.end;
                 continue;
             }
             if (!isMap && ctx.options.strict && utilContainsNewline.containsNewline(key))
@@ -107,9 +101,9 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                 onError(keyNode.range, 'BLOCK_IN_FLOW', blockMsg);
             // value properties
             const valueProps = resolveProps.resolveProps(sep || [], {
+                ctx,
                 flow: fcName,
                 indicator: 'map-value-ind',
-                next: value,
                 offset: keyNode.range[2],
                 onError,
                 startOnNewline: false
@@ -152,14 +146,8 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
                     keyNode.comment = valueProps.comment;
             }
             const pair = new Pair.Pair(keyNode, valueNode);
-            if (ctx.options.keepSourceTokens)
-                pair.srcToken = collItem;
-            if (isMap) {
-                const map = coll;
-                if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode))
-                    onError(keyStart, 'DUPLICATE_KEY', 'Map keys must be unique');
-                map.items.push(pair);
-            }
+            if (isMap)
+                coll.items.push(pair);
             else {
                 const map = new YAMLMap.YAMLMap(ctx.schema);
                 map.flow = true;
@@ -173,13 +161,9 @@ function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onErr
     const [ce, ...ee] = fc.end;
     let cePos = offset;
     if (ce && ce.source === expectedEnd)
-        cePos = ce.offset + ce.source.length;
+        cePos += ce.source.length;
     else {
-        const name = fcName[0].toUpperCase() + fcName.substring(1);
-        const msg = atRoot
-            ? `${name} must end with a ${expectedEnd}`
-            : `${name} in block collection must be sufficiently indented and end with a ${expectedEnd}`;
-        onError(offset, atRoot ? 'MISSING_CHAR' : 'BAD_INDENT', msg);
+        onError(offset + 1, 'MISSING_CHAR', `Expected ${fcName} to end with ${expectedEnd}`);
         if (ce && ce.source.length !== 1)
             ee.unshift(ce);
     }

package/dist/compose/resolve-flow-scalar.js

@@ -41,31 +41,25 @@ function resolveFlowScalar(scalar, strict, onError) {
     };
 }
 function plainValue(source, onError) {
-    let badChar = '';
+    let message = '';
     switch (source[0]) {
         /* istanbul ignore next should not happen */
         case '\t':
-            badChar = 'a tab character';
-            break;
-        case ',':
-            badChar = 'flow indicator character ,';
-            break;
-        case '%':
-            badChar = 'directive indicator character %';
+            message = 'Plain value cannot start with a tab character';
             break;
         case '|':
         case '>': {
-            badChar = `block scalar indicator ${source[0]}`;
+            message = `Plain value cannot start with block scalar indicator ${source[0]}`;
             break;
         }
         case '@':
         case '`': {
-            badChar = `reserved character ${source[0]}`;
+            message = `Plain value cannot start with reserved character ${source[0]}`;
             break;
         }
     }
-    if (badChar)
-        onError(0, 'BAD_SCALAR_START', `Plain value cannot start with ${badChar}`);
+    if (message)
+        onError(0, 'BAD_SCALAR_START', message);
     return foldLines(source);
 }
 function singleQuotedValue(source, onError) {
@@ -137,12 +131,6 @@ function doubleQuotedValue(source, onError) {
                 while (next === ' ' || next === '\t')
                     next = source[++i + 1];
             }
-            else if (next === '\r' && source[i + 1] === '\n') {
-                // skip escaped CRLF newlines, but still trim the following line
-                next = source[++i + 1];
-                while (next === ' ' || next === '\t')
-                    next = source[++i + 1];
-            }
             else if (next === 'x' || next === 'u' || next === 'U') {
                 const length = { x: 2, u: 4, U: 8 }[next];
                 res += parseCharCode(source, i + 1, length, onError);
@@ -160,7 +148,7 @@ function doubleQuotedValue(source, onError) {
             let next = source[i + 1];
             while (next === ' ' || next === '\t')
                 next = source[++i + 1];
-            if (next !== '\n' && !(next === '\r' && source[i + 2] === '\n'))
+            if (next !== '\n')
                 res += i > wsStart ? source.slice(wsStart, i + 1) : ch;
         }
         else {

package/dist/compose/resolve-props.d.ts

@@ -1,14 +1,15 @@
-import type { SourceToken, Token } from '../parse/cst.js';
+import type { SourceToken } from '../parse/cst.js';
+import type { ComposeContext } from './compose-node.js';
 import type { ComposeErrorHandler } from './composer.js';
 export interface ResolvePropsArg {
+    ctx: ComposeContext;
     flow?: string;
     indicator: 'doc-start' | 'explicit-key-ind' | 'map-value-ind' | 'seq-item-ind';
-    next: Token | null | undefined;
     offset: number;
     onError: ComposeErrorHandler;
     startOnNewline: boolean;
 }
-export declare function resolveProps(tokens: SourceToken[], { flow, indicator, next, offset, onError, startOnNewline }: ResolvePropsArg): {
+export declare function resolveProps(tokens: SourceToken[], { ctx, flow, indicator, offset, onError, startOnNewline }: ResolvePropsArg): {
     comma: SourceToken | null;
     found: SourceToken | null;
     spaceBefore: boolean;