yaml 2.3.0-4 → 2.3.0-5

package/browser/dist/compose/compose-collection.js

@@ -1,38 +1,50 @@
-import { isNode, isMap } from '../nodes/identity.js';
+import { isNode } from '../nodes/identity.js';
 import { Scalar } from '../nodes/Scalar.js';
+import { YAMLMap } from '../nodes/YAMLMap.js';
+import { YAMLSeq } from '../nodes/YAMLSeq.js';
 import { resolveBlockMap } from './resolve-block-map.js';
 import { resolveBlockSeq } from './resolve-block-seq.js';
 import { resolveFlowCollection } from './resolve-flow-collection.js';
 
-function composeCollection(CN, ctx, token, tagToken, onError) {
-    let coll;
-    switch (token.type) {
-        case 'block-map': {
-            coll = resolveBlockMap(CN, ctx, token, onError);
-            break;
-        }
-        case 'block-seq': {
-            coll = resolveBlockSeq(CN, ctx, token, onError);
-            break;
-        }
-        case 'flow-collection': {
-            coll = resolveFlowCollection(CN, ctx, token, onError);
-            break;
-        }
-    }
-    if (!tagToken)
-        return coll;
-    const tagName = ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg));
-    if (!tagName)
-        return coll;
-    // Cast needed due to: https://github.com/Microsoft/TypeScript/issues/3841
+function resolveCollection(CN, ctx, token, onError, tagName, tag) {
+    const coll = token.type === 'block-map'
+        ? resolveBlockMap(CN, ctx, token, onError, tag)
+        : token.type === 'block-seq'
+            ? resolveBlockSeq(CN, ctx, token, onError, tag)
+            : resolveFlowCollection(CN, ctx, token, onError, tag);
     const Coll = coll.constructor;
+    // If we got a tagName matching the class, or the tag name is '!',
+    // then use the tagName from the node class used to create it.
     if (tagName === '!' || tagName === Coll.tagName) {
         coll.tag = Coll.tagName;
         return coll;
     }
-    const expType = isMap(coll) ? 'map' : 'seq';
-    let tag = ctx.schema.tags.find(t => t.collection === expType && t.tag === tagName);
+    if (tagName)
+        coll.tag = tagName;
+    return coll;
+}
+function composeCollection(CN, ctx, token, tagToken, onError) {
+    const tagName = !tagToken
+        ? null
+        : ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg));
+    const expType = token.type === 'block-map'
+        ? 'map'
+        : token.type === 'block-seq'
+            ? 'seq'
+            : token.start.source === '{'
+                ? 'map'
+                : 'seq';
+    // shortcut: check if it's a generic YAMLMap or YAMLSeq
+    // before jumping into the custom tag logic.
+    if (!tagToken ||
+        !tagName ||
+        tagName === '!' ||
+        (tagName === YAMLMap.tagName && expType === 'map') ||
+        (tagName === YAMLSeq.tagName && expType === 'seq') ||
+        !expType) {
+        return resolveCollection(CN, ctx, token, onError, tagName);
+    }
+    let tag = ctx.schema.tags.find(t => t.tag === tagName && t.collection === expType);
     if (!tag) {
         const kt = ctx.schema.knownTags[tagName];
         if (kt && kt.collection === expType) {
@@ -40,12 +52,17 @@ function composeCollection(CN, ctx, token, tagToken, onError) {
             tag = kt;
         }
         else {
-            onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, true);
-            coll.tag = tagName;
-            return coll;
+            if (kt?.collection) {
+                onError(tagToken, 'BAD_COLLECTION_TYPE', `${kt.tag} used for ${expType} collection, but expects ${kt.collection}`, true);
+            }
+            else {
+                onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, true);
+            }
+            return resolveCollection(CN, ctx, token, onError, tagName);
         }
     }
-    const res = tag.resolve(coll, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg), ctx.options);
+    const coll = resolveCollection(CN, ctx, token, onError, tagName, tag);
+    const res = tag.resolve?.(coll, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg), ctx.options) ?? coll;
     const node = isNode(res)
         ? res
         : new Scalar(res);

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

@@ -6,8 +6,9 @@ import { flowIndentCheck } from './util-flow-indent-check.js';
 import { mapIncludes } from './util-map-includes.js';
 
 const startColMsg = 'All mapping items must start at the same column';
-function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError) {
-    const map = new YAMLMap(ctx.schema);
+function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError, tag) {
+    const NodeClass = tag?.nodeClass ?? YAMLMap;
+    const map = new NodeClass(ctx.schema);
     if (ctx.atRoot)
         ctx.atRoot = false;
     let offset = bm.offset;

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

@@ -2,8 +2,9 @@ import { YAMLSeq } from '../nodes/YAMLSeq.js';
 import { resolveProps } from './resolve-props.js';
 import { flowIndentCheck } from './util-flow-indent-check.js';
 
-function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError) {
-    const seq = new YAMLSeq(ctx.schema);
+function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError, tag) {
+    const NodeClass = tag?.nodeClass ?? YAMLSeq;
+    const seq = new NodeClass(ctx.schema);
     if (ctx.atRoot)
         ctx.atRoot = false;
     let offset = bs.offset;

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

@@ -9,12 +9,11 @@ import { mapIncludes } from './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');
-function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onError) {
+function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onError, tag) {
     const isMap = fc.start.source === '{';
     const fcName = isMap ? 'flow map' : 'flow sequence';
-    const coll = isMap
-        ? new YAMLMap(ctx.schema)
-        : new YAMLSeq(ctx.schema);
+    const NodeClass = (tag?.nodeClass ?? (isMap ? YAMLMap : YAMLSeq));
+    const coll = new NodeClass(ctx.schema);
     coll.flow = true;
     const atRoot = ctx.atRoot;
     if (atRoot)

package/browser/dist/doc/createNode.js

@@ -74,7 +74,9 @@ function createNode(value, tagName, ctx) {
     }
     const node = tagObj?.createNode
         ? tagObj.createNode(ctx.schema, value, ctx)
-        : new Scalar(value);
+        : typeof tagObj?.nodeClass?.from === 'function'
+            ? tagObj.nodeClass.from(ctx.schema, value, ctx)
+            : new Scalar(value);
     if (tagName)
         node.tag = tagName;
     else if (!tagObj.default)

package/browser/dist/errors.js

@@ -47,7 +47,7 @@ const prettifyError = (src, lc) => (error) => {
         let count = 1;
         const end = error.linePos[1];
         if (end && end.line === line && end.col > col) {
-            count = Math.min(end.col - col, 80 - ci);
+            count = Math.max(1, Math.min(end.col - col, 80 - ci));
         }
         const pointer = ' '.repeat(ci) + '^'.repeat(count);
         error.message += `:\n\n${lineStr}\n${pointer}\n`;

package/browser/dist/nodes/YAMLMap.js

@@ -2,7 +2,7 @@ import { stringifyCollection } from '../stringify/stringifyCollection.js';
 import { addPairToJSMap } from './addPairToJSMap.js';
 import { Collection } from './Collection.js';
 import { isPair, isScalar, MAP } from './identity.js';
-import { Pair } from './Pair.js';
+import { Pair, createPair } from './Pair.js';
 import { isScalarValue } from './Scalar.js';
 
 function findPair(items, key) {
@@ -25,6 +25,34 @@ class YAMLMap extends Collection {
         super(MAP, schema);
         this.items = [];
     }
+    /**
+     * A generic collection parsing method that can be extended
+     * to other node classes that inherit from YAMLMap
+     */
+    static from(schema, obj, ctx) {
+        const { keepUndefined, replacer } = ctx;
+        const map = new this(schema);
+        const add = (key, value) => {
+            if (typeof replacer === 'function')
+                value = replacer.call(obj, key, value);
+            else if (Array.isArray(replacer) && !replacer.includes(key))
+                return;
+            if (value !== undefined || keepUndefined)
+                map.items.push(createPair(key, value, ctx));
+        };
+        if (obj instanceof Map) {
+            for (const [key, value] of obj)
+                add(key, value);
+        }
+        else if (obj && typeof obj === 'object') {
+            for (const key of Object.keys(obj))
+                add(key, obj[key]);
+        }
+        if (typeof schema.sortMapEntries === 'function') {
+            map.items.sort(schema.sortMapEntries);
+        }
+        return map;
+    }
     /**
      * Adds a value to the collection.
      *

package/browser/dist/nodes/YAMLSeq.js

@@ -1,3 +1,4 @@
+import { createNode } from '../doc/createNode.js';
 import { stringifyCollection } from '../stringify/stringifyCollection.js';
 import { Collection } from './Collection.js';
 import { SEQ, isScalar } from './identity.js';
@@ -84,6 +85,21 @@ class YAMLSeq extends Collection {
             onComment
         });
     }
+    static from(schema, obj, ctx) {
+        const { replacer } = ctx;
+        const seq = new this(schema);
+        if (obj && Symbol.iterator in Object(obj)) {
+            let i = 0;
+            for (let it of obj) {
+                if (typeof replacer === 'function') {
+                    const key = obj instanceof Set ? it : String(i++);
+                    it = replacer.call(obj, key, it);
+                }
+                seq.items.push(createNode(it, undefined, ctx));
+            }
+        }
+        return seq;
+    }
 }
 function asItemIndex(key) {
     let idx = isScalar(key) ? key.value : key;

package/browser/dist/schema/common/map.js

@@ -1,34 +1,8 @@
 import { isMap } from '../../nodes/identity.js';
-import { createPair } from '../../nodes/Pair.js';
 import { YAMLMap } from '../../nodes/YAMLMap.js';
 
-function createMap(schema, obj, ctx) {
-    const { keepUndefined, replacer } = ctx;
-    const map = new YAMLMap(schema);
-    const add = (key, value) => {
-        if (typeof replacer === 'function')
-            value = replacer.call(obj, key, value);
-        else if (Array.isArray(replacer) && !replacer.includes(key))
-            return;
-        if (value !== undefined || keepUndefined)
-            map.items.push(createPair(key, value, ctx));
-    };
-    if (obj instanceof Map) {
-        for (const [key, value] of obj)
-            add(key, value);
-    }
-    else if (obj && typeof obj === 'object') {
-        for (const key of Object.keys(obj))
-            add(key, obj[key]);
-    }
-    if (typeof schema.sortMapEntries === 'function') {
-        map.items.sort(schema.sortMapEntries);
-    }
-    return map;
-}
 const map = {
     collection: 'map',
-    createNode: createMap,
     default: true,
     nodeClass: YAMLMap,
     tag: 'tag:yaml.org,2002:map',
@@ -36,7 +10,8 @@ const map = {
         if (!isMap(map))
             onError('Expected a mapping for this tag');
         return map;
-    }
+    },
+    createNode: (schema, obj, ctx) => YAMLMap.from(schema, obj, ctx)
 };
 
 export { map };

package/browser/dist/schema/common/seq.js

@@ -1,25 +1,8 @@
-import { createNode } from '../../doc/createNode.js';
 import { isSeq } from '../../nodes/identity.js';
 import { YAMLSeq } from '../../nodes/YAMLSeq.js';
 
-function createSeq(schema, obj, ctx) {
-    const { replacer } = ctx;
-    const seq = new YAMLSeq(schema);
-    if (obj && Symbol.iterator in Object(obj)) {
-        let i = 0;
-        for (let it of obj) {
-            if (typeof replacer === 'function') {
-                const key = obj instanceof Set ? it : String(i++);
-                it = replacer.call(obj, key, it);
-            }
-            seq.items.push(createNode(it, undefined, ctx));
-        }
-    }
-    return seq;
-}
 const seq = {
     collection: 'seq',
-    createNode: createSeq,
     default: true,
     nodeClass: YAMLSeq,
     tag: 'tag:yaml.org,2002:seq',
@@ -27,7 +10,8 @@ const seq = {
         if (!isSeq(seq))
             onError('Expected a sequence for this tag');
         return seq;
-    }
+    },
+    createNode: (schema, obj, ctx) => YAMLSeq.from(schema, obj, ctx)
 };
 
 export { seq };

package/browser/dist/schema/yaml-1.1/omap.js

@@ -39,6 +39,12 @@ class YAMLOMap extends YAMLSeq {
         }
         return map;
     }
+    static from(schema, iterable, ctx) {
+        const pairs = createPairs(schema, iterable, ctx);
+        const omap = new this();
+        omap.items = pairs.items;
+        return omap;
+    }
 }
 YAMLOMap.tag = 'tag:yaml.org,2002:omap';
 const omap = {
@@ -62,12 +68,7 @@ const omap = {
         }
         return Object.assign(new YAMLOMap(), pairs);
     },
-    createNode(schema, iterable, ctx) {
-        const pairs = createPairs(schema, iterable, ctx);
-        const omap = new YAMLOMap();
-        omap.items = pairs.items;
-        return omap;
-    }
+    createNode: (schema, iterable, ctx) => YAMLOMap.from(schema, iterable, ctx)
 };
 
 export { YAMLOMap, omap };

package/browser/dist/schema/yaml-1.1/set.js

@@ -1,5 +1,5 @@
 import { isMap, isPair, isScalar } from '../../nodes/identity.js';
-import { createPair, Pair } from '../../nodes/Pair.js';
+import { Pair, createPair } from '../../nodes/Pair.js';
 import { YAMLMap, findPair } from '../../nodes/YAMLMap.js';
 
 class YAMLSet extends YAMLMap {
@@ -57,6 +57,17 @@ class YAMLSet extends YAMLMap {
         else
             throw new Error('Set items must all have null values');
     }
+    static from(schema, iterable, ctx) {
+        const { replacer } = ctx;
+        const set = new this(schema);
+        if (iterable && Symbol.iterator in Object(iterable))
+            for (let value of iterable) {
+                if (typeof replacer === 'function')
+                    value = replacer.call(iterable, value, value);
+                set.items.push(createPair(value, null, ctx));
+            }
+        return set;
+    }
 }
 YAMLSet.tag = 'tag:yaml.org,2002:set';
 const set = {
@@ -65,6 +76,7 @@ const set = {
     nodeClass: YAMLSet,
     default: false,
     tag: 'tag:yaml.org,2002:set',
+    createNode: (schema, iterable, ctx) => YAMLSet.from(schema, iterable, ctx),
     resolve(map, onError) {
         if (isMap(map)) {
             if (map.hasAllNullValues(true))
@@ -75,17 +87,6 @@ const set = {
         else
             onError('Expected a mapping for this tag');
         return map;
-    },
-    createNode(schema, iterable, ctx) {
-        const { replacer } = ctx;
-        const set = new YAMLSet(schema);
-        if (iterable && Symbol.iterator in Object(iterable))
-            for (let value of iterable) {
-                if (typeof replacer === 'function')
-                    value = replacer.call(iterable, value, value);
-                set.items.push(createPair(value, null, ctx));
-            }
-        return set;
     }
 };
 

package/browser/dist/schema/yaml-1.1/timestamp.js

@@ -43,7 +43,7 @@ function stringifySexagesimal(node) {
     }
     return (sign +
         parts
-            .map(n => (n < 10 ? '0' + String(n) : String(n)))
+            .map(n => String(n).padStart(2, '0'))
             .join(':')
             .replace(/000000\d*$/, '') // % 60 may introduce error
     );

package/dist/compose/compose-collection.js

@@ -2,39 +2,51 @@
 
 var identity = require('../nodes/identity.js');
 var Scalar = require('../nodes/Scalar.js');
+var YAMLMap = require('../nodes/YAMLMap.js');
+var YAMLSeq = require('../nodes/YAMLSeq.js');
 var resolveBlockMap = require('./resolve-block-map.js');
 var resolveBlockSeq = require('./resolve-block-seq.js');
 var resolveFlowCollection = require('./resolve-flow-collection.js');
 
-function composeCollection(CN, ctx, token, tagToken, onError) {
-    let coll;
-    switch (token.type) {
-        case 'block-map': {
-            coll = resolveBlockMap.resolveBlockMap(CN, ctx, token, onError);
-            break;
-        }
-        case 'block-seq': {
-            coll = resolveBlockSeq.resolveBlockSeq(CN, ctx, token, onError);
-            break;
-        }
-        case 'flow-collection': {
-            coll = resolveFlowCollection.resolveFlowCollection(CN, ctx, token, onError);
-            break;
-        }
-    }
-    if (!tagToken)
-        return coll;
-    const tagName = ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg));
-    if (!tagName)
-        return coll;
-    // Cast needed due to: https://github.com/Microsoft/TypeScript/issues/3841
+function resolveCollection(CN, ctx, token, onError, tagName, tag) {
+    const coll = token.type === 'block-map'
+        ? resolveBlockMap.resolveBlockMap(CN, ctx, token, onError, tag)
+        : token.type === 'block-seq'
+            ? resolveBlockSeq.resolveBlockSeq(CN, ctx, token, onError, tag)
+            : resolveFlowCollection.resolveFlowCollection(CN, ctx, token, onError, tag);
     const Coll = coll.constructor;
+    // If we got a tagName matching the class, or the tag name is '!',
+    // then use the tagName from the node class used to create it.
     if (tagName === '!' || tagName === Coll.tagName) {
         coll.tag = Coll.tagName;
         return coll;
     }
-    const expType = identity.isMap(coll) ? 'map' : 'seq';
-    let tag = ctx.schema.tags.find(t => t.collection === expType && t.tag === tagName);
+    if (tagName)
+        coll.tag = tagName;
+    return coll;
+}
+function composeCollection(CN, ctx, token, tagToken, onError) {
+    const tagName = !tagToken
+        ? null
+        : ctx.directives.tagName(tagToken.source, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg));
+    const expType = token.type === 'block-map'
+        ? 'map'
+        : token.type === 'block-seq'
+            ? 'seq'
+            : token.start.source === '{'
+                ? 'map'
+                : 'seq';
+    // shortcut: check if it's a generic YAMLMap or YAMLSeq
+    // before jumping into the custom tag logic.
+    if (!tagToken ||
+        !tagName ||
+        tagName === '!' ||
+        (tagName === YAMLMap.YAMLMap.tagName && expType === 'map') ||
+        (tagName === YAMLSeq.YAMLSeq.tagName && expType === 'seq') ||
+        !expType) {
+        return resolveCollection(CN, ctx, token, onError, tagName);
+    }
+    let tag = ctx.schema.tags.find(t => t.tag === tagName && t.collection === expType);
     if (!tag) {
         const kt = ctx.schema.knownTags[tagName];
         if (kt && kt.collection === expType) {
@@ -42,12 +54,17 @@ function composeCollection(CN, ctx, token, tagToken, onError) {
             tag = kt;
         }
         else {
-            onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, true);
-            coll.tag = tagName;
-            return coll;
+            if (kt?.collection) {
+                onError(tagToken, 'BAD_COLLECTION_TYPE', `${kt.tag} used for ${expType} collection, but expects ${kt.collection}`, true);
+            }
+            else {
+                onError(tagToken, 'TAG_RESOLVE_FAILED', `Unresolved tag: ${tagName}`, true);
+            }
+            return resolveCollection(CN, ctx, token, onError, tagName);
         }
     }
-    const res = tag.resolve(coll, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg), ctx.options);
+    const coll = resolveCollection(CN, ctx, token, onError, tagName, tag);
+    const res = tag.resolve?.(coll, msg => onError(tagToken, 'TAG_RESOLVE_FAILED', msg), ctx.options) ?? coll;
     const node = identity.isNode(res)
         ? res
         : new Scalar.Scalar(res);

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

@@ -1,6 +1,7 @@
 import type { ParsedNode } from '../nodes/Node.js';
 import { YAMLMap } from '../nodes/YAMLMap.js';
 import type { BlockMap } from '../parse/cst.js';
+import { CollectionTag } from '../schema/types.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, tag?: CollectionTag): YAMLMap.Parsed<ParsedNode, ParsedNode | null>;

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

@@ -8,8 +8,9 @@ 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) {
-    const map = new YAMLMap.YAMLMap(ctx.schema);
+function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError, tag) {
+    const NodeClass = tag?.nodeClass ?? YAMLMap.YAMLMap;
+    const map = new NodeClass(ctx.schema);
     if (ctx.atRoot)
         ctx.atRoot = false;
     let offset = bm.offset;

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

@@ -1,5 +1,6 @@
 import { YAMLSeq } from '../nodes/YAMLSeq.js';
 import type { BlockSequence } from '../parse/cst.js';
+import { CollectionTag } from '../schema/types.js';
 import type { ComposeContext, ComposeNode } from './compose-node.js';
 import type { ComposeErrorHandler } from './composer.js';
-export declare function resolveBlockSeq({ composeNode, composeEmptyNode }: ComposeNode, ctx: ComposeContext, bs: BlockSequence, onError: ComposeErrorHandler): YAMLSeq.Parsed<import("../index.js").ParsedNode>;
+export declare function resolveBlockSeq({ composeNode, composeEmptyNode }: ComposeNode, ctx: ComposeContext, bs: BlockSequence, onError: ComposeErrorHandler, tag?: CollectionTag): YAMLSeq.Parsed<import("../index.js").ParsedNode>;

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

@@ -4,8 +4,9 @@ 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);
+function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError, tag) {
+    const NodeClass = tag?.nodeClass ?? YAMLSeq.YAMLSeq;
+    const seq = new NodeClass(ctx.schema);
     if (ctx.atRoot)
         ctx.atRoot = false;
     let offset = bs.offset;

package/dist/compose/resolve-flow-collection.d.ts

@@ -1,6 +1,7 @@
 import { YAMLMap } from '../nodes/YAMLMap.js';
 import { YAMLSeq } from '../nodes/YAMLSeq.js';
 import type { FlowCollection } from '../parse/cst.js';
+import { CollectionTag } from '../schema/types.js';
 import type { ComposeContext, ComposeNode } from './compose-node.js';
 import type { ComposeErrorHandler } from './composer.js';
-export declare function resolveFlowCollection({ composeNode, composeEmptyNode }: ComposeNode, ctx: ComposeContext, fc: FlowCollection, onError: ComposeErrorHandler): YAMLMap.Parsed<import("../index.js").ParsedNode, import("../index.js").ParsedNode | null> | YAMLSeq.Parsed<import("../index.js").ParsedNode>;
+export declare function resolveFlowCollection({ composeNode, composeEmptyNode }: ComposeNode, ctx: ComposeContext, fc: FlowCollection, onError: ComposeErrorHandler, tag?: CollectionTag): YAMLMap.Parsed<import("../index.js").ParsedNode, import("../index.js").ParsedNode | null> | YAMLSeq.Parsed<import("../index.js").ParsedNode>;

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

@@ -11,12 +11,11 @@ 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');
-function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onError) {
+function resolveFlowCollection({ composeNode, composeEmptyNode }, ctx, fc, onError, tag) {
     const isMap = fc.start.source === '{';
     const fcName = isMap ? 'flow map' : 'flow sequence';
-    const coll = isMap
-        ? new YAMLMap.YAMLMap(ctx.schema)
-        : new YAMLSeq.YAMLSeq(ctx.schema);
+    const NodeClass = (tag?.nodeClass ?? (isMap ? YAMLMap.YAMLMap : YAMLSeq.YAMLSeq));
+    const coll = new NodeClass(ctx.schema);
     coll.flow = true;
     const atRoot = ctx.atRoot;
     if (atRoot)

package/dist/doc/createNode.js

@@ -76,7 +76,9 @@ function createNode(value, tagName, ctx) {
     }
     const node = tagObj?.createNode
         ? tagObj.createNode(ctx.schema, value, ctx)
-        : new Scalar.Scalar(value);
+        : typeof tagObj?.nodeClass?.from === 'function'
+            ? tagObj.nodeClass.from(ctx.schema, value, ctx)
+            : new Scalar.Scalar(value);
     if (tagName)
         node.tag = tagName;
     else if (!tagObj.default)

package/dist/errors.d.ts

@@ -1,5 +1,5 @@
 import type { LineCounter } from './parse/line-counter';
-export type ErrorCode = 'ALIAS_PROPS' | 'BAD_ALIAS' | 'BAD_DIRECTIVE' | 'BAD_DQ_ESCAPE' | 'BAD_INDENT' | 'BAD_PROP_ORDER' | 'BAD_SCALAR_START' | 'BLOCK_AS_IMPLICIT_KEY' | 'BLOCK_IN_FLOW' | 'DUPLICATE_KEY' | 'IMPOSSIBLE' | 'KEY_OVER_1024_CHARS' | 'MISSING_CHAR' | 'MULTILINE_IMPLICIT_KEY' | 'MULTIPLE_ANCHORS' | 'MULTIPLE_DOCS' | 'MULTIPLE_TAGS' | 'TAB_AS_INDENT' | 'TAG_RESOLVE_FAILED' | 'UNEXPECTED_TOKEN';
+export type ErrorCode = 'ALIAS_PROPS' | 'BAD_ALIAS' | 'BAD_DIRECTIVE' | 'BAD_DQ_ESCAPE' | 'BAD_INDENT' | 'BAD_PROP_ORDER' | 'BAD_SCALAR_START' | 'BLOCK_AS_IMPLICIT_KEY' | 'BLOCK_IN_FLOW' | 'DUPLICATE_KEY' | 'IMPOSSIBLE' | 'KEY_OVER_1024_CHARS' | 'MISSING_CHAR' | 'MULTILINE_IMPLICIT_KEY' | 'MULTIPLE_ANCHORS' | 'MULTIPLE_DOCS' | 'MULTIPLE_TAGS' | 'TAB_AS_INDENT' | 'TAG_RESOLVE_FAILED' | 'UNEXPECTED_TOKEN' | 'BAD_COLLECTION_TYPE';
 export type LinePos = {
     line: number;
     col: number;

package/dist/errors.js

@@ -49,7 +49,7 @@ const prettifyError = (src, lc) => (error) => {
         let count = 1;
         const end = error.linePos[1];
         if (end && end.line === line && end.col > col) {
-            count = Math.min(end.col - col, 80 - ci);
+            count = Math.max(1, Math.min(end.col - col, 80 - ci));
         }
         const pointer = ' '.repeat(ci) + '^'.repeat(count);
         error.message += `:\n\n${lineStr}\n${pointer}\n`;

package/dist/nodes/Pair.d.ts

@@ -5,7 +5,7 @@ import type { StringifyContext } from '../stringify/stringify.js';
 import { addPairToJSMap } from './addPairToJSMap.js';
 import { NODE_TYPE } from './identity.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 function createPair(key: unknown, value: unknown, ctx: CreateNodeContext): Pair<import("./Node.js").Node, import("./YAMLMap.js").YAMLMap<unknown, unknown> | import("./Scalar.js").Scalar<unknown> | import("./Alias.js").Alias | import("./YAMLSeq.js").YAMLSeq<unknown>>;
 export declare class Pair<K = unknown, V = unknown> {
     readonly [NODE_TYPE]: symbol;
     /** Always Node or null when parsed, but can be set to anything. */

package/dist/nodes/YAMLMap.d.ts

@@ -1,6 +1,7 @@
 import type { BlockMap, FlowCollection } from '../parse/cst.js';
 import type { Schema } from '../schema/Schema.js';
 import type { StringifyContext } from '../stringify/stringify.js';
+import { CreateNodeContext } from '../util.js';
 import { Collection } from './Collection.js';
 import type { ParsedNode, Range } from './Node.js';
 import { Pair } from './Pair.js';
@@ -19,6 +20,11 @@ export declare class YAMLMap<K = unknown, V = unknown> extends Collection {
     static get tagName(): 'tag:yaml.org,2002:map';
     items: Pair<K, V>[];
     constructor(schema?: Schema);
+    /**
+     * A generic collection parsing method that can be extended
+     * to other node classes that inherit from YAMLMap
+     */
+    static from(schema: Schema, obj: unknown, ctx: CreateNodeContext): YAMLMap<unknown, unknown>;
     /**
      * Adds a value to the collection.
      *

package/dist/nodes/YAMLMap.js

@@ -27,6 +27,34 @@ class YAMLMap extends Collection.Collection {
         super(identity.MAP, schema);
         this.items = [];
     }
+    /**
+     * A generic collection parsing method that can be extended
+     * to other node classes that inherit from YAMLMap
+     */
+    static from(schema, obj, ctx) {
+        const { keepUndefined, replacer } = ctx;
+        const map = new this(schema);
+        const add = (key, value) => {
+            if (typeof replacer === 'function')
+                value = replacer.call(obj, key, value);
+            else if (Array.isArray(replacer) && !replacer.includes(key))
+                return;
+            if (value !== undefined || keepUndefined)
+                map.items.push(Pair.createPair(key, value, ctx));
+        };
+        if (obj instanceof Map) {
+            for (const [key, value] of obj)
+                add(key, value);
+        }
+        else if (obj && typeof obj === 'object') {
+            for (const key of Object.keys(obj))
+                add(key, obj[key]);
+        }
+        if (typeof schema.sortMapEntries === 'function') {
+            map.items.sort(schema.sortMapEntries);
+        }
+        return map;
+    }
     /**
      * Adds a value to the collection.
      *

package/dist/nodes/YAMLSeq.d.ts

@@ -1,3 +1,4 @@
+import { CreateNodeContext } from '../doc/createNode.js';
 import type { BlockSequence, FlowCollection } from '../parse/cst.js';
 import type { Schema } from '../schema/Schema.js';
 import type { StringifyContext } from '../stringify/stringify.js';
@@ -55,4 +56,5 @@ export declare class YAMLSeq<T = unknown> extends Collection {
     set(key: unknown, value: T): void;
     toJSON(_?: unknown, ctx?: ToJSContext): unknown[];
     toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
+    static from(schema: Schema, obj: unknown, ctx: CreateNodeContext): YAMLSeq<unknown>;
 }

package/dist/nodes/YAMLSeq.js

@@ -1,5 +1,6 @@
 'use strict';
 
+var createNode = require('../doc/createNode.js');
 var stringifyCollection = require('../stringify/stringifyCollection.js');
 var Collection = require('./Collection.js');
 var identity = require('./identity.js');
@@ -86,6 +87,21 @@ class YAMLSeq extends Collection.Collection {
             onComment
         });
     }
+    static from(schema, obj, ctx) {
+        const { replacer } = ctx;
+        const seq = new this(schema);
+        if (obj && Symbol.iterator in Object(obj)) {
+            let i = 0;
+            for (let it of obj) {
+                if (typeof replacer === 'function') {
+                    const key = obj instanceof Set ? it : String(i++);
+                    it = replacer.call(obj, key, it);
+                }
+                seq.items.push(createNode.createNode(it, undefined, ctx));
+            }
+        }
+        return seq;
+    }
 }
 function asItemIndex(key) {
     let idx = identity.isScalar(key) ? key.value : key;

package/dist/schema/common/map.js

@@ -1,36 +1,10 @@
 'use strict';
 
 var identity = require('../../nodes/identity.js');
-var Pair = require('../../nodes/Pair.js');
 var YAMLMap = require('../../nodes/YAMLMap.js');
 
-function createMap(schema, obj, ctx) {
-    const { keepUndefined, replacer } = ctx;
-    const map = new YAMLMap.YAMLMap(schema);
-    const add = (key, value) => {
-        if (typeof replacer === 'function')
-            value = replacer.call(obj, key, value);
-        else if (Array.isArray(replacer) && !replacer.includes(key))
-            return;
-        if (value !== undefined || keepUndefined)
-            map.items.push(Pair.createPair(key, value, ctx));
-    };
-    if (obj instanceof Map) {
-        for (const [key, value] of obj)
-            add(key, value);
-    }
-    else if (obj && typeof obj === 'object') {
-        for (const key of Object.keys(obj))
-            add(key, obj[key]);
-    }
-    if (typeof schema.sortMapEntries === 'function') {
-        map.items.sort(schema.sortMapEntries);
-    }
-    return map;
-}
 const map = {
     collection: 'map',
-    createNode: createMap,
     default: true,
     nodeClass: YAMLMap.YAMLMap,
     tag: 'tag:yaml.org,2002:map',
@@ -38,7 +12,8 @@ const map = {
         if (!identity.isMap(map))
             onError('Expected a mapping for this tag');
         return map;
-    }
+    },
+    createNode: (schema, obj, ctx) => YAMLMap.YAMLMap.from(schema, obj, ctx)
 };
 
 exports.map = map;

package/dist/schema/common/seq.js

@@ -1,27 +1,10 @@
 'use strict';
 
-var createNode = require('../../doc/createNode.js');
 var identity = require('../../nodes/identity.js');
 var YAMLSeq = require('../../nodes/YAMLSeq.js');
 
-function createSeq(schema, obj, ctx) {
-    const { replacer } = ctx;
-    const seq = new YAMLSeq.YAMLSeq(schema);
-    if (obj && Symbol.iterator in Object(obj)) {
-        let i = 0;
-        for (let it of obj) {
-            if (typeof replacer === 'function') {
-                const key = obj instanceof Set ? it : String(i++);
-                it = replacer.call(obj, key, it);
-            }
-            seq.items.push(createNode.createNode(it, undefined, ctx));
-        }
-    }
-    return seq;
-}
 const seq = {
     collection: 'seq',
-    createNode: createSeq,
     default: true,
     nodeClass: YAMLSeq.YAMLSeq,
     tag: 'tag:yaml.org,2002:seq',
@@ -29,7 +12,8 @@ const seq = {
         if (!identity.isSeq(seq))
             onError('Expected a sequence for this tag');
         return seq;
-    }
+    },
+    createNode: (schema, obj, ctx) => YAMLSeq.YAMLSeq.from(schema, obj, ctx)
 };
 
 exports.seq = seq;

package/dist/schema/types.d.ts

@@ -1,11 +1,11 @@
 import type { CreateNodeContext } from '../doc/createNode.js';
-import type { Schema } from './Schema.js';
 import type { Node } from '../nodes/Node.js';
 import type { Scalar } from '../nodes/Scalar.js';
 import type { YAMLMap } from '../nodes/YAMLMap.js';
 import type { YAMLSeq } from '../nodes/YAMLSeq.js';
 import type { ParseOptions } from '../options.js';
 import type { StringifyContext } from '../stringify/stringify.js';
+import type { Schema } from './Schema.js';
 interface TagBase {
     /**
      * An optional factory function, used e.g. by collections when wrapping JS objects as AST nodes.
@@ -71,12 +71,20 @@ export interface CollectionTag extends TagBase {
     /**
      * The `Node` child class that implements this tag.
      * If set, used to select this tag when stringifying.
+     *
+     * If the class provides a static `from` method, then that
+     * will be used if the tag object doesn't have a `createNode` method.
      */
-    nodeClass?: new () => Node;
+    nodeClass?: {
+        new (schema?: Schema): Node;
+        from?: (schema: Schema, obj: unknown, ctx: CreateNodeContext) => Node;
+    };
     /**
      * Turns a value into an AST node.
      * If returning a non-`Node` value, the output will be wrapped as a `Scalar`.
+     *
+     * Note: this is required if nodeClass is not provided.
      */
-    resolve(value: YAMLMap.Parsed | YAMLSeq.Parsed, onError: (message: string) => void, options: ParseOptions): unknown;
+    resolve?: (value: YAMLMap.Parsed | YAMLSeq.Parsed, onError: (message: string) => void, options: ParseOptions) => unknown;
 }
 export {};

package/dist/schema/yaml-1.1/omap.d.ts

@@ -1,5 +1,7 @@
 import { ToJSContext } from '../../nodes/toJS.js';
 import { YAMLSeq } from '../../nodes/YAMLSeq.js';
+import { CreateNodeContext } from '../../util.js';
+import type { Schema } from '../Schema.js';
 import { CollectionTag } from '../types.js';
 export declare class YAMLOMap extends YAMLSeq {
     static tag: string;
@@ -21,5 +23,6 @@ export declare class YAMLOMap extends YAMLSeq {
      * but TypeScript won't allow widening the signature of a child method.
      */
     toJSON(_?: unknown, ctx?: ToJSContext): unknown[];
+    static from(schema: Schema, iterable: unknown, ctx: CreateNodeContext): YAMLOMap;
 }
 export declare const omap: CollectionTag;

package/dist/schema/yaml-1.1/omap.js

@@ -41,6 +41,12 @@ class YAMLOMap extends YAMLSeq.YAMLSeq {
         }
         return map;
     }
+    static from(schema, iterable, ctx) {
+        const pairs$1 = pairs.createPairs(schema, iterable, ctx);
+        const omap = new this();
+        omap.items = pairs$1.items;
+        return omap;
+    }
 }
 YAMLOMap.tag = 'tag:yaml.org,2002:omap';
 const omap = {
@@ -64,12 +70,7 @@ const omap = {
         }
         return Object.assign(new YAMLOMap(), pairs$1);
     },
-    createNode(schema, iterable, ctx) {
-        const pairs$1 = pairs.createPairs(schema, iterable, ctx);
-        const omap = new YAMLOMap();
-        omap.items = pairs$1.items;
-        return omap;
-    }
+    createNode: (schema, iterable, ctx) => YAMLOMap.from(schema, iterable, ctx)
 };
 
 exports.YAMLOMap = YAMLOMap;

package/dist/schema/yaml-1.1/set.d.ts

@@ -1,9 +1,10 @@
-import type { Schema } from '../../schema/Schema.js';
 import { Pair } from '../../nodes/Pair.js';
 import { Scalar } from '../../nodes/Scalar.js';
 import { ToJSContext } from '../../nodes/toJS.js';
 import { YAMLMap } from '../../nodes/YAMLMap.js';
+import type { Schema } from '../../schema/Schema.js';
 import type { StringifyContext } from '../../stringify/stringify.js';
+import { CreateNodeContext } from '../../util.js';
 import type { CollectionTag } from '../types.js';
 export declare class YAMLSet<T = unknown> extends YAMLMap<T, Scalar<null> | null> {
     static tag: string;
@@ -22,5 +23,6 @@ export declare class YAMLSet<T = unknown> extends YAMLMap<T, Scalar<null> | null
     set(key: T, value: null): void;
     toJSON(_?: unknown, ctx?: ToJSContext): any;
     toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
+    static from(schema: Schema, iterable: unknown, ctx: CreateNodeContext): YAMLSet<unknown>;
 }
 export declare const set: CollectionTag;

package/dist/schema/yaml-1.1/set.js

@@ -59,6 +59,17 @@ class YAMLSet extends YAMLMap.YAMLMap {
         else
             throw new Error('Set items must all have null values');
     }
+    static from(schema, iterable, ctx) {
+        const { replacer } = ctx;
+        const set = new this(schema);
+        if (iterable && Symbol.iterator in Object(iterable))
+            for (let value of iterable) {
+                if (typeof replacer === 'function')
+                    value = replacer.call(iterable, value, value);
+                set.items.push(Pair.createPair(value, null, ctx));
+            }
+        return set;
+    }
 }
 YAMLSet.tag = 'tag:yaml.org,2002:set';
 const set = {
@@ -67,6 +78,7 @@ const set = {
     nodeClass: YAMLSet,
     default: false,
     tag: 'tag:yaml.org,2002:set',
+    createNode: (schema, iterable, ctx) => YAMLSet.from(schema, iterable, ctx),
     resolve(map, onError) {
         if (identity.isMap(map)) {
             if (map.hasAllNullValues(true))
@@ -77,17 +89,6 @@ const set = {
         else
             onError('Expected a mapping for this tag');
         return map;
-    },
-    createNode(schema, iterable, ctx) {
-        const { replacer } = ctx;
-        const set = new YAMLSet(schema);
-        if (iterable && Symbol.iterator in Object(iterable))
-            for (let value of iterable) {
-                if (typeof replacer === 'function')
-                    value = replacer.call(iterable, value, value);
-                set.items.push(Pair.createPair(value, null, ctx));
-            }
-        return set;
     }
 };
 

package/dist/schema/yaml-1.1/timestamp.js

@@ -45,7 +45,7 @@ function stringifySexagesimal(node) {
     }
     return (sign +
         parts
-            .map(n => (n < 10 ? '0' + String(n) : String(n)))
+            .map(n => String(n).padStart(2, '0'))
             .join(':')
             .replace(/000000\d*$/, '') // % 60 may introduce error
     );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yaml",
-  "version": "2.3.0-4",
+  "version": "2.3.0-5",
   "license": "ISC",
   "author": "Eemeli Aro <eemeli@gmail.com>",
   "repository": "github:eemeli/yaml",