yaml 2.0.0-5 → 2.0.0-9

package/dist/nodes/Collection.js

@@ -13,19 +13,14 @@ function collectionFromPath(schema, path, value) {
             v = a;
         }
         else {
-            const o = {};
-            Object.defineProperty(o, typeof k === 'symbol' ? k : String(k), {
-                value: v,
-                writable: true,
-                enumerable: true,
-                configurable: true
-            });
-            v = o;
+            v = new Map([[k, v]]);
         }
     }
     return createNode.createNode(v, undefined, {
-        onAnchor() {
-            throw new Error('Repeated objects are not supported here');
+        aliasDuplicateObjects: false,
+        keepUndefined: false,
+        onAnchor: () => {
+            throw new Error('This should not happen, please report a bug.');
         },
         schema,
         sourceObjects: new Map()
@@ -44,6 +39,20 @@ class Collection extends Node.NodeBase {
             writable: true
         });
     }
+    /**
+     * Create a copy of this collection.
+     *
+     * @param schema - If defined, overwrites the original's schema
+     */
+    clone(schema) {
+        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+        if (schema)
+            copy.schema = schema;
+        copy.items = copy.items.map(it => Node.isNode(it) || Node.isPair(it) ? it.clone(schema) : it);
+        if (this.range)
+            copy.range = this.range.slice();
+        return copy;
+    }
     /**
      * Adds a value to the collection. For `!!map` and `!!omap` the value must
      * be a Pair instance or a `{ key, value }` object, which may not have a key
@@ -67,7 +76,8 @@ class Collection extends Node.NodeBase {
      * Removes a value from the collection.
      * @returns `true` if the item was found and removed.
      */
-    deleteIn([key, ...rest]) {
+    deleteIn(path) {
+        const [key, ...rest] = path;
         if (rest.length === 0)
             return this.delete(key);
         const node = this.get(key, true);
@@ -81,7 +91,8 @@ class Collection extends Node.NodeBase {
      * scalar values from their surrounding node; to disable set `keepScalar` to
      * `true` (collections are always returned intact).
      */
-    getIn([key, ...rest], keepScalar) {
+    getIn(path, keepScalar) {
+        const [key, ...rest] = path;
         const node = this.get(key, true);
         if (rest.length === 0)
             return !keepScalar && Node.isScalar(node) ? node.value : node;
@@ -105,7 +116,8 @@ class Collection extends Node.NodeBase {
     /**
      * Checks if the collection includes a value with the key `key`.
      */
-    hasIn([key, ...rest]) {
+    hasIn(path) {
+        const [key, ...rest] = path;
         if (rest.length === 0)
             return this.has(key);
         const node = this.get(key, true);
@@ -115,7 +127,8 @@ class Collection extends Node.NodeBase {
      * Sets a value in this collection. For `!!set`, `value` needs to be a
      * boolean to add/remove the item from the set.
      */
-    setIn([key, ...rest], value) {
+    setIn(path, value) {
+        const [key, ...rest] = path;
         if (rest.length === 0) {
             this.set(key, value);
         }

package/dist/nodes/Node.d.ts

@@ -1,4 +1,5 @@
 import type { Document } from '../doc/Document.js';
+import { Token } from '../parse/cst.js';
 import type { StringifyContext } from '../stringify/stringify.js';
 import type { Alias } from './Alias.js';
 import type { Pair } from './Pair.js';
@@ -23,7 +24,7 @@ export declare const isScalar: (node: any) => node is Scalar<unknown>;
 export declare const isSeq: (node: any) => node is YAMLSeq<unknown>;
 export declare function isCollection(node: any): node is YAMLMap | YAMLSeq;
 export declare function isNode(node: any): node is Node;
-export declare const hasAnchor: (node: unknown) => node is YAMLMap<unknown, unknown> | YAMLSeq<unknown> | Scalar<unknown>;
+export declare const hasAnchor: (node: unknown) => node is Scalar<unknown> | YAMLMap<unknown, unknown> | YAMLSeq<unknown>;
 export declare abstract class NodeBase {
     readonly [NODE_TYPE]: symbol;
     /** A comment on or immediately after this */
@@ -31,16 +32,22 @@ export declare abstract class NodeBase {
     /** A comment before this */
     commentBefore?: string | null;
     /**
-     * The [start, value-end, node-end] character offsets for the part of the
-     * source parsed into this node (undefined if not parsed).
+     * The `[start, value-end, node-end]` character offsets for the part of the
+     * source parsed into this node (undefined if not parsed). The `value-end`
+     * and `node-end` positions are themselves not included in their respective
+     * ranges.
      */
     range?: Range | null;
     /** A blank line before this node and its commentBefore */
     spaceBefore?: boolean;
+    /** The CST token that was composed into this node.  */
+    srcToken?: Token;
     /** A fully qualified tag, if required */
     tag?: string;
     /** A plain JS representation of this node */
     abstract toJSON(): any;
     abstract toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
     constructor(type: symbol);
+    /** Create a copy of this node.  */
+    clone(): NodeBase;
 }

package/dist/nodes/Node.js

@@ -38,6 +38,13 @@ class NodeBase {
     constructor(type) {
         Object.defineProperty(this, NODE_TYPE, { value: type });
     }
+    /** Create a copy of this node.  */
+    clone() {
+        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+        if (this.range)
+            copy.range = this.range.slice();
+        return copy;
+    }
 }
 
 exports.ALIAS = ALIAS;

package/dist/nodes/Pair.d.ts

@@ -1,8 +1,10 @@
 import { CreateNodeContext } from '../doc/createNode.js';
-import { StringifyContext } from '../stringify/stringify.js';
+import type { CollectionItem } from '../parse/cst.js';
+import type { Schema } from '../schema/Schema.js';
+import type { StringifyContext } from '../stringify/stringify.js';
 import { addPairToJSMap } from './addPairToJSMap.js';
 import { NODE_TYPE } from './Node.js';
-import { ToJSContext } from './toJS.js';
+import type { ToJSContext } from './toJS.js';
 export declare function createPair(key: unknown, value: unknown, ctx: CreateNodeContext): Pair<import("./Node.js").Node, import("./Alias.js").Alias | import("./Scalar.js").Scalar<unknown> | import("./YAMLMap.js").YAMLMap<unknown, unknown> | import("./YAMLSeq.js").YAMLSeq<unknown>>;
 export declare class Pair<K = unknown, V = unknown> {
     readonly [NODE_TYPE]: symbol;
@@ -10,7 +12,10 @@ export declare class Pair<K = unknown, V = unknown> {
     key: K;
     /** Always Node or null when parsed, but can be set to anything. */
     value: V | null;
+    /** The CST token that was composed into this pair.  */
+    srcToken?: CollectionItem;
     constructor(key: K, value?: V | null);
+    clone(schema?: Schema): Pair<K, V>;
     toJSON(_?: unknown, ctx?: ToJSContext): ReturnType<typeof addPairToJSMap>;
     toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
 }

package/dist/nodes/Pair.js

@@ -16,6 +16,14 @@ class Pair {
         this.key = key;
         this.value = value;
     }
+    clone(schema) {
+        let { key, value } = this;
+        if (Node.isNode(key))
+            key = key.clone(schema);
+        if (Node.isNode(value))
+            value = value.clone(schema);
+        return new Pair(key, value);
+    }
     toJSON(_, ctx) {
         const pair = ctx && ctx.mapAsMap ? new Map() : {};
         return addPairToJSMap.addPairToJSMap(ctx, pair, this);

package/dist/nodes/Scalar.d.ts

@@ -1,3 +1,4 @@
+import type { BlockScalar, FlowScalar } from '../parse/cst.js';
 import { NodeBase, Range } from './Node.js';
 import { ToJSContext } from './toJS.js';
 export declare const isScalarValue: (value: unknown) => boolean;
@@ -5,6 +6,7 @@ export declare namespace Scalar {
     interface Parsed extends Scalar {
         range: Range;
         source: string;
+        srcToken?: FlowScalar | BlockScalar;
     }
     type BLOCK_FOLDED = 'BLOCK_FOLDED';
     type BLOCK_LITERAL = 'BLOCK_LITERAL';

package/dist/nodes/YAMLMap.d.ts

@@ -1,3 +1,4 @@
+import type { BlockMap, FlowCollection } from '../parse/cst.js';
 import type { Schema } from '../schema/Schema.js';
 import type { StringifyContext } from '../stringify/stringify.js';
 import { Collection } from './Collection.js';
@@ -9,6 +10,7 @@ export declare namespace YAMLMap {
     interface Parsed<K extends ParsedNode = ParsedNode, V extends ParsedNode | null = ParsedNode | null> extends YAMLMap<K, V> {
         items: Pair<K, V>[];
         range: Range;
+        srcToken?: BlockMap | FlowCollection;
     }
 }
 export declare class YAMLMap<K = unknown, V = unknown> extends Collection {

package/dist/nodes/YAMLSeq.d.ts

@@ -1,3 +1,4 @@
+import type { BlockSequence, FlowCollection } from '../parse/cst.js';
 import type { Schema } from '../schema/Schema.js';
 import type { StringifyContext } from '../stringify/stringify.js';
 import { Collection } from './Collection.js';
@@ -8,6 +9,7 @@ export declare namespace YAMLSeq {
     interface Parsed<T extends ParsedNode | Pair<ParsedNode, ParsedNode | null> = ParsedNode> extends YAMLSeq<T> {
         items: T[];
         range: Range;
+        srcToken?: BlockSequence | FlowCollection;
     }
 }
 export declare class YAMLSeq<T = unknown> extends Collection {

package/dist/nodes/addPairToJSMap.js

@@ -9,6 +9,7 @@ var toJS = require('./toJS.js');
 const MERGE_KEY = '<<';
 function addPairToJSMap(ctx, map, { key, value }) {
     if (ctx && ctx.doc.schema.merge && isMergeKey(key)) {
+        value = Node.isAlias(value) ? value.resolve(ctx.doc) : value;
         if (Node.isSeq(value))
             for (const it of value.items)
                 mergeToJSMap(ctx, map, it);
@@ -54,9 +55,9 @@ const isMergeKey = (key) => key === MERGE_KEY ||
 // Keys in mapping nodes earlier in the sequence override keys specified in
 // later mapping nodes. -- http://yaml.org/type/merge.html
 function mergeToJSMap(ctx, map, value) {
-    const source = ctx && Node.isAlias(value) ? value.resolve(ctx.doc) : null;
+    const source = ctx && Node.isAlias(value) ? value.resolve(ctx.doc) : value;
     if (!Node.isMap(source))
-        throw new Error('Merge sources must be map aliases');
+        throw new Error('Merge sources must be maps or map aliases');
     const srcMap = source.toJSON(null, ctx, Map);
     for (const [key, value] of srcMap) {
         if (map instanceof Map) {

package/dist/options.d.ts

@@ -1,6 +1,7 @@
 import type { Reviver } from './doc/applyReviver.js';
 import type { Directives } from './doc/directives.js';
 import type { LogLevelId } from './log.js';
+import type { ParsedNode } from './nodes/Node.js';
 import type { Pair } from './nodes/Pair.js';
 import type { Scalar } from './nodes/Scalar.js';
 import type { LineCounter } from './parse/line-counter.js';
@@ -16,6 +17,13 @@ export declare type ParseOptions = {
      * https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/BigInt
      */
     intAsBigInt?: boolean;
+    /**
+     * Include a `srcToken` value on each parsed `Node`, containing the CST token
+     * that was composed into this node.
+     *
+     * Default: `false`
+     */
+    keepSourceTokens?: boolean;
     /**
      * If set, newlines will be tracked, to allow for `lineCounter.linePos(offset)`
      * to provide the `{ line, col }` positions within the input.
@@ -34,6 +42,19 @@ export declare type ParseOptions = {
      * Default: `true`
      */
     strict?: boolean;
+    /**
+     * YAML requires map keys to be unique. By default, this is checked by
+     * comparing scalar values with `===`; deep equality is not checked for
+     * aliases or collections. If merge keys are enabled by the schema,
+     * multiple `<<` keys are allowed.
+     *
+     * Set `false` to disable, or provide your own comparator function to
+     * customise. The comparator will be passed two `ParsedNode` values, and
+     * is expected to return a `boolean` indicating their equality.
+     *
+     * Default: `true`
+     */
+    uniqueKeys?: boolean | ((a: ParsedNode, b: ParsedNode) => boolean);
 };
 export declare type DocumentOptions = {
     /**
@@ -84,12 +105,20 @@ export declare type SchemaOptions = {
     /**
      * When adding to or stringifying a map, sort the entries.
      * If `true`, sort by comparing key values with `<`.
+     * Does not affect item order when parsing.
      *
      * Default: `false`
      */
     sortMapEntries?: boolean | ((a: Pair, b: Pair) => number);
 };
 export declare type CreateNodeOptions = {
+    /**
+     * During node construction, use anchors and aliases to keep strictly equal
+     * non-null objects as equivalent in YAML.
+     *
+     * Default: `true`
+     */
+    aliasDuplicateObjects?: boolean;
     /**
      * Default prefix for anchors.
      *
@@ -139,6 +168,13 @@ export declare type ToJSOptions = {
     reviver?: Reviver;
 };
 export declare type ToStringOptions = {
+    /**
+     * Use block quote styles for scalar values where applicable.
+     * Set to `false` to disable block quotes completely.
+     *
+     * Default: `true`
+     */
+    blockQuote?: boolean | 'folded' | 'literal';
     /**
      * The default type of string literal used to stringify implicit key values.
      * Output may use other types if required to fully represent the value.
@@ -232,11 +268,12 @@ export declare type ToStringOptions = {
      */
     simpleKeys?: boolean;
     /**
-     * Prefer 'single quote' rather than "double quote" where applicable.
+     * Use 'single quote' rather than "double quote" where applicable.
+     * Set to `false` to disable single quotes completely.
      *
-     * Default: `false`
+     * Default: `null`
      */
-    singleQuote?: boolean;
+    singleQuote?: boolean | null;
     /**
      * String representation for `true`.
      * With the core schema, use `'true'`, `'True'`, or `'TRUE'`.

package/dist/options.js

@@ -9,9 +9,11 @@
  */
 const defaultOptions = {
     intAsBigInt: false,
+    keepSourceTokens: false,
     logLevel: 'warn',
     prettyErrors: true,
     strict: true,
+    uniqueKeys: true,
     version: '1.2'
 };
 

package/dist/parse/cst-scalar.d.ts

@@ -6,6 +6,12 @@ import type { BlockScalar, FlowScalar, SourceToken, Token } from './cst.js';
  * If `token` is a CST flow or block scalar, determine its string value and a few other attributes.
  * Otherwise, return `null`.
  */
+export declare function resolveAsScalar(token: FlowScalar | BlockScalar, strict?: boolean, onError?: (offset: number, code: ErrorCode, message: string) => void): {
+    value: string;
+    type: Scalar.Type | null;
+    comment: string;
+    range: Range;
+};
 export declare function resolveAsScalar(token: Token | null | undefined, strict?: boolean, onError?: (offset: number, code: ErrorCode, message: string) => void): {
     value: string;
     type: Scalar.Type | null;

package/dist/parse/cst-scalar.js

@@ -5,10 +5,6 @@ var resolveFlowScalar = require('../compose/resolve-flow-scalar.js');
 var errors = require('../errors.js');
 var stringifyString = require('../stringify/stringifyString.js');
 
-/**
- * If `token` is a CST flow or block scalar, determine its string value and a few other attributes.
- * Otherwise, return `null`.
- */
 function resolveAsScalar(token, strict = true, onError) {
     if (token) {
         const _onError = (pos, code, message) => {
@@ -50,7 +46,7 @@ function createScalarToken(value, context) {
         implicitKey,
         indent: indent > 0 ? ' '.repeat(indent) : '',
         inFlow,
-        options: { lineWidth: -1 }
+        options: { blockQuote: true, lineWidth: -1 }
     });
     const end = (_a = context.end) !== null && _a !== void 0 ? _a : [
         { type: 'newline', offset: -1, indent, source: '\n' }
@@ -119,7 +115,7 @@ function setScalarValue(token, value, context = {}) {
         implicitKey: implicitKey || indent === null,
         indent: indent !== null && indent > 0 ? ' '.repeat(indent) : '',
         inFlow,
-        options: { lineWidth: -1 }
+        options: { blockQuote: true, lineWidth: -1 }
     });
     switch (source[0]) {
         case '|':

package/dist/parse/lexer.d.ts

@@ -47,6 +47,8 @@ export declare class Lexer {
     private indentNext;
     /** Indentation level of the current line. */
     private indentValue;
+    /** Position of the next \n character. */
+    private lineEndPos;
     /** Stores the state of the lexer if reaching the end of incpomplete input */
     private next;
     /** A pointer to `buffer`; the current position of the lexer. */
@@ -78,7 +80,7 @@ export declare class Lexer {
     private pushCount;
     private pushToIndex;
     private pushIndicators;
-    private pushVerbatimTag;
+    private pushTag;
     private pushNewline;
     private pushSpaces;
     private pushUntil;

package/dist/parse/lexer.js

@@ -81,9 +81,11 @@ function isEmpty(ch) {
             return false;
     }
 }
-const invalidFlowScalarChars = [',', '[', ']', '{', '}'];
-const invalidIdentifierChars = [' ', ',', '[', ']', '{', '}', '\n', '\r', '\t'];
-const isNotIdentifierChar = (ch) => !ch || invalidIdentifierChars.includes(ch);
+const hexDigits = '0123456789ABCDEFabcdef'.split('');
+const tagChars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-#;/?:@&=+$_.!~*'()".split('');
+const invalidFlowScalarChars = ',[]{}'.split('');
+const invalidAnchorChars = ' ,[]{}\n\r\t'.split('');
+const isNotAnchorChar = (ch) => !ch || invalidAnchorChars.includes(ch);
 /**
  * Splits an input string into lexical tokens, i.e. smaller strings that are
  * easily identifiable by `tokens.tokenType()`.
@@ -134,6 +136,8 @@ class Lexer {
         this.indentNext = 0;
         /** Indentation level of the current line. */
         this.indentValue = 0;
+        /** Position of the next \n character. */
+        this.lineEndPos = null;
         /** Stores the state of the lexer if reaching the end of incpomplete input */
         this.next = null;
         /** A pointer to `buffer`; the current position of the lexer. */
@@ -146,8 +150,10 @@ class Lexer {
      * @returns A generator of lexical tokens
      */
     *lex(source, incomplete = false) {
-        if (source)
+        if (source) {
             this.buffer = this.buffer ? this.buffer + source : source;
+            this.lineEndPos = null;
+        }
         this.atEnd = !incomplete;
         let next = this.next || 'stream';
         while (next && (incomplete || this.hasChars(1)))
@@ -190,7 +196,11 @@ class Lexer {
         return offset;
     }
     getLine() {
-        let end = this.buffer.indexOf('\n', this.pos);
+        let end = this.lineEndPos;
+        if (typeof end !== 'number' || (end !== -1 && end < this.pos)) {
+            end = this.buffer.indexOf('\n', this.pos);
+            this.lineEndPos = end;
+        }
         if (end === -1)
             return this.atEnd ? this.buffer.substring(this.pos) : null;
         if (this.buffer[end - 1] === '\r')
@@ -203,6 +213,7 @@ class Lexer {
     setNext(state) {
         this.buffer = this.buffer.substring(this.pos);
         this.pos = 0;
+        this.lineEndPos = null;
         this.next = state;
         return null;
     }
@@ -327,7 +338,7 @@ class Lexer {
                 yield* this.pushCount(1);
                 return 'doc';
             case '*':
-                yield* this.pushUntil(isNotIdentifierChar);
+                yield* this.pushUntil(isNotAnchorChar);
                 return 'doc';
             case '"':
             case "'":
@@ -355,7 +366,7 @@ class Lexer {
         const line = this.getLine();
         if (line === null)
             return this.setNext('flow');
-        if ((indent !== -1 && indent < this.indentNext) ||
+        if ((indent !== -1 && indent < this.indentNext && line[0] !== '#') ||
             (indent === 0 &&
                 (line.startsWith('---') || line.startsWith('...')) &&
                 isEmpty(line[3]))) {
@@ -373,8 +384,11 @@ class Lexer {
             }
         }
         let n = 0;
-        while (line[n] === ',')
-            n += (yield* this.pushCount(1)) + (yield* this.pushSpaces(true));
+        while (line[n] === ',') {
+            n += yield* this.pushCount(1);
+            n += yield* this.pushSpaces(true);
+            this.flowKey = false;
+        }
         n += yield* this.pushIndicators();
         switch (line[n]) {
             case undefined:
@@ -395,7 +409,7 @@ class Lexer {
                 this.flowLevel -= 1;
                 return this.flowLevel ? 'flow' : 'doc';
             case '*':
-                yield* this.pushUntil(isNotIdentifierChar);
+                yield* this.pushUntil(isNotAnchorChar);
                 return 'flow';
             case '"':
             case "'":
@@ -433,17 +447,19 @@ class Lexer {
                 end = this.buffer.indexOf('"', end + 1);
             }
         }
-        let nl = this.buffer.indexOf('\n', this.pos);
-        if (nl !== -1 && nl < end) {
-            while (nl !== -1 && nl < end) {
+        // Only looking for newlines within the quotes
+        const qb = this.buffer.substring(0, end);
+        let nl = qb.indexOf('\n', this.pos);
+        if (nl !== -1) {
+            while (nl !== -1) {
                 const cs = this.continueScalar(nl + 1);
                 if (cs === -1)
                     break;
-                nl = this.buffer.indexOf('\n', cs);
+                nl = qb.indexOf('\n', cs);
             }
-            if (nl !== -1 && nl < end) {
+            if (nl !== -1) {
                 // this is an error caused by an unexpected unindent
-                end = nl - 1;
+                end = nl - (qb[nl - 1] === '\r' ? 2 : 1);
             }
         }
         if (end === -1) {
@@ -543,17 +559,18 @@ class Lexer {
                 end = i;
             }
             else if (isEmpty(ch)) {
-                const next = this.buffer[i + 1];
-                if (next === '#' || (inFlow && invalidFlowScalarChars.includes(next)))
-                    break;
+                let next = this.buffer[i + 1];
                 if (ch === '\r') {
                     if (next === '\n') {
                         i += 1;
                         ch = '\n';
+                        next = this.buffer[i + 1];
                     }
                     else
                         end = i;
                 }
+                if (next === '#' || (inFlow && invalidFlowScalarChars.includes(next)))
+                    break;
                 if (ch === '\n') {
                     const cs = this.continueScalar(i + 1);
                     if (cs === -1)
@@ -595,13 +612,11 @@ class Lexer {
     *pushIndicators() {
         switch (this.charAt(0)) {
             case '!':
-                if (this.charAt(1) === '<')
-                    return ((yield* this.pushVerbatimTag()) +
-                        (yield* this.pushSpaces(true)) +
-                        (yield* this.pushIndicators()));
-            // fallthrough
+                return ((yield* this.pushTag()) +
+                    (yield* this.pushSpaces(true)) +
+                    (yield* this.pushIndicators()));
             case '&':
-                return ((yield* this.pushUntil(isNotIdentifierChar)) +
+                return ((yield* this.pushUntil(isNotAnchorChar)) +
                     (yield* this.pushSpaces(true)) +
                     (yield* this.pushIndicators()));
             case ':':
@@ -617,12 +632,30 @@ class Lexer {
         }
         return 0;
     }
-    *pushVerbatimTag() {
-        let i = this.pos + 2;
-        let ch = this.buffer[i];
-        while (!isEmpty(ch) && ch !== '>')
-            ch = this.buffer[++i];
-        return yield* this.pushToIndex(ch === '>' ? i + 1 : i, false);
+    *pushTag() {
+        if (this.charAt(1) === '<') {
+            let i = this.pos + 2;
+            let ch = this.buffer[i];
+            while (!isEmpty(ch) && ch !== '>')
+                ch = this.buffer[++i];
+            return yield* this.pushToIndex(ch === '>' ? i + 1 : i, false);
+        }
+        else {
+            let i = this.pos + 1;
+            let ch = this.buffer[i];
+            while (ch) {
+                if (tagChars.includes(ch))
+                    ch = this.buffer[++i];
+                else if (ch === '%' &&
+                    hexDigits.includes(this.buffer[i + 1]) &&
+                    hexDigits.includes(this.buffer[i + 2])) {
+                    ch = this.buffer[(i += 3)];
+                }
+                else
+                    break;
+            }
+            return yield* this.pushToIndex(i, false);
+        }
     }
     *pushNewline() {
         const ch = this.buffer[this.pos];

package/dist/parse/parser.d.ts

@@ -78,6 +78,7 @@ export declare class Parser {
     private flowCollection;
     private flowScalar;
     private startBlockValue;
+    private atIndentedComment;
     private documentEnd;
     private lineEnd;
 }