yaml 2.0.0-4 → 2.0.0-8

package/browser/dist/public-api.js

@@ -21,13 +21,11 @@ function parseOptions(options) {
  *   EmptyStream and contain additional stream information. In
  *   TypeScript, you should use `'empty' in docs` as a type guard for it.
  */
-function parseAllDocuments(source, options) {
+function parseAllDocuments(source, options = {}) {
     const { lineCounter, prettyErrors } = parseOptions(options);
-    const docs = [];
-    const composer = new Composer(doc => docs.push(doc), options);
-    const parser = new Parser(composer.next, lineCounter === null || lineCounter === void 0 ? void 0 : lineCounter.addNewLine);
-    parser.parse(source);
-    composer.end();
+    const parser = new Parser(lineCounter === null || lineCounter === void 0 ? void 0 : lineCounter.addNewLine);
+    const composer = new Composer(options);
+    const docs = Array.from(composer.compose(parser.parse(source)));
     if (prettyErrors && lineCounter)
         for (const doc of docs) {
             doc.errors.forEach(prettifyError(source, lineCounter));
@@ -38,21 +36,20 @@ function parseAllDocuments(source, options) {
     return Object.assign([], { empty: true }, composer.streamInfo());
 }
 /** Parse an input string into a single YAML.Document */
-function parseDocument(source, options) {
+function parseDocument(source, options = {}) {
     const { lineCounter, prettyErrors } = parseOptions(options);
+    const parser = new Parser(lineCounter === null || lineCounter === void 0 ? void 0 : lineCounter.addNewLine);
+    const composer = new Composer(options);
     // `doc` is always set by compose.end(true) at the very latest
     let doc = null;
-    const composer = new Composer(_doc => {
+    for (const _doc of composer.compose(parser.parse(source), true, source.length)) {
         if (!doc)
             doc = _doc;
         else if (doc.options.logLevel !== 'silent') {
-            const errMsg = 'Source contains multiple documents; please use YAML.parseAllDocuments()';
-            doc.errors.push(new YAMLParseError(_doc.range[0], errMsg));
+            doc.errors.push(new YAMLParseError(_doc.range.slice(0, 2), 'MULTIPLE_DOCS', 'Source contains multiple documents; please use YAML.parseAllDocuments()'));
+            break;
         }
-    }, options);
-    const parser = new Parser(composer.next, lineCounter === null || lineCounter === void 0 ? void 0 : lineCounter.addNewLine);
-    parser.parse(source);
-    composer.end(true, source.length);
+    }
     if (prettyErrors && lineCounter) {
         doc.errors.forEach(prettifyError(source, lineCounter));
         doc.warnings.forEach(prettifyError(source, lineCounter));

package/browser/dist/schema/Schema.js

@@ -0,0 +1,28 @@
+import { MAP, SCALAR, SEQ } from '../nodes/Node.js';
+import { map } from './common/map.js';
+import { seq } from './common/seq.js';
+import { string } from './common/string.js';
+import { coreKnownTags, getTags } from './tags.js';
+
+const sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
+class Schema {
+    constructor({ customTags, merge, resolveKnownTags, schema, sortMapEntries }) {
+        this.merge = !!merge;
+        this.name = schema || 'core';
+        this.knownTags = resolveKnownTags ? coreKnownTags : {};
+        this.tags = getTags(customTags, this.name);
+        Object.defineProperty(this, MAP, { value: map });
+        Object.defineProperty(this, SCALAR, { value: string });
+        Object.defineProperty(this, SEQ, { value: seq });
+        // Used by createMap()
+        this.sortMapEntries =
+            sortMapEntries === true ? sortMapEntriesByKey : sortMapEntries || null;
+    }
+    clone() {
+        const copy = Object.create(Schema.prototype, Object.getOwnPropertyDescriptors(this));
+        copy.tags = this.tags.slice();
+        return copy;
+    }
+}
+
+export { Schema };

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

@@ -0,0 +1,13 @@
+import { Scalar } from '../../nodes/Scalar.js';
+
+const nullTag = {
+    identify: value => value == null,
+    createNode: () => new Scalar(null),
+    default: true,
+    tag: 'tag:yaml.org,2002:null',
+    test: /^(?:~|[Nn]ull|NULL)?$/,
+    resolve: () => new Scalar(null),
+    stringify: ({ source }, ctx) => source && nullTag.test.test(source) ? source : ctx.options.nullStr
+};
+
+export { nullTag };

package/browser/dist/{tags/failsafe → schema/common}/seq.js

@@ -1,6 +1,6 @@
+import { createNode } from '../../doc/createNode.js';
 import { isSeq } from '../../nodes/Node.js';
 import { YAMLSeq } from '../../nodes/YAMLSeq.js';
-import { createNode } from '../../doc/createNode.js';
 
 function createSeq(schema, obj, ctx) {
     const { replacer } = ctx;

package/browser/dist/schema/core/bool.js

@@ -0,0 +1,19 @@
+import { Scalar } from '../../nodes/Scalar.js';
+
+const boolTag = {
+    identify: value => typeof value === 'boolean',
+    default: true,
+    tag: 'tag:yaml.org,2002:bool',
+    test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
+    resolve: str => new Scalar(str[0] === 't' || str[0] === 'T'),
+    stringify({ source, value }, ctx) {
+        if (source && boolTag.test.test(source)) {
+            const sv = source[0] === 't' || source[0] === 'T';
+            if (value === sv)
+                return source;
+        }
+        return value ? ctx.options.trueStr : ctx.options.falseStr;
+    }
+};
+
+export { boolTag };

package/browser/dist/schema/core/float.js

@@ -0,0 +1,40 @@
+import { Scalar } from '../../nodes/Scalar.js';
+import { stringifyNumber } from '../../stringify/stringifyNumber.js';
+
+const floatNaN = {
+    identify: value => typeof value === 'number',
+    default: true,
+    tag: 'tag:yaml.org,2002:float',
+    test: /^(?:[-+]?\.(?:inf|Inf|INF|nan|NaN|NAN))$/,
+    resolve: str => str.slice(-3).toLowerCase() === 'nan'
+        ? NaN
+        : str[0] === '-'
+            ? Number.NEGATIVE_INFINITY
+            : Number.POSITIVE_INFINITY,
+    stringify: stringifyNumber
+};
+const floatExp = {
+    identify: value => typeof value === 'number',
+    default: true,
+    tag: 'tag:yaml.org,2002:float',
+    format: 'EXP',
+    test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/,
+    resolve: str => parseFloat(str),
+    stringify: ({ value }) => Number(value).toExponential()
+};
+const float = {
+    identify: value => typeof value === 'number',
+    default: true,
+    tag: 'tag:yaml.org,2002:float',
+    test: /^[-+]?(?:\.[0-9]+|[0-9]+\.[0-9]*)$/,
+    resolve(str) {
+        const node = new Scalar(parseFloat(str));
+        const dot = str.indexOf('.');
+        if (dot !== -1 && str[str.length - 1] === '0')
+            node.minFractionDigits = str.length - dot - 1;
+        return node;
+    },
+    stringify: stringifyNumber
+};
+
+export { float, floatExp, floatNaN };

package/browser/dist/schema/core/int.js

@@ -0,0 +1,38 @@
+import { stringifyNumber } from '../../stringify/stringifyNumber.js';
+
+const intIdentify = (value) => typeof value === 'bigint' || Number.isInteger(value);
+const intResolve = (str, offset, radix, { intAsBigInt }) => (intAsBigInt ? BigInt(str) : parseInt(str.substring(offset), radix));
+function intStringify(node, radix, prefix) {
+    const { value } = node;
+    if (intIdentify(value) && value >= 0)
+        return prefix + value.toString(radix);
+    return stringifyNumber(node);
+}
+const intOct = {
+    identify: value => intIdentify(value) && value >= 0,
+    default: true,
+    tag: 'tag:yaml.org,2002:int',
+    format: 'OCT',
+    test: /^0o[0-7]+$/,
+    resolve: (str, _onError, opt) => intResolve(str, 2, 8, opt),
+    stringify: node => intStringify(node, 8, '0o')
+};
+const int = {
+    identify: intIdentify,
+    default: true,
+    tag: 'tag:yaml.org,2002:int',
+    test: /^[-+]?[0-9]+$/,
+    resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),
+    stringify: stringifyNumber
+};
+const intHex = {
+    identify: value => intIdentify(value) && value >= 0,
+    default: true,
+    tag: 'tag:yaml.org,2002:int',
+    format: 'HEX',
+    test: /^0x[0-9a-fA-F]+$/,
+    resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),
+    stringify: node => intStringify(node, 16, '0x')
+};
+
+export { int, intHex, intOct };

package/browser/dist/schema/core/schema.js

@@ -0,0 +1,23 @@
+import { map } from '../common/map.js';
+import { nullTag } from '../common/null.js';
+import { seq } from '../common/seq.js';
+import { string } from '../common/string.js';
+import { boolTag } from './bool.js';
+import { floatNaN, floatExp, float } from './float.js';
+import { intOct, int, intHex } from './int.js';
+
+const schema = [
+    map,
+    seq,
+    string,
+    nullTag,
+    boolTag,
+    intOct,
+    int,
+    intHex,
+    floatNaN,
+    floatExp,
+    float
+];
+
+export { schema };

package/browser/dist/{tags/json.js → schema/json/schema.js}

@@ -1,8 +1,7 @@
-import { Scalar } from '../nodes/Scalar.js';
-import { map } from './failsafe/map.js';
-import { seq } from './failsafe/seq.js';
+import { Scalar } from '../../nodes/Scalar.js';
+import { map } from '../common/map.js';
+import { seq } from '../common/seq.js';
 
-/* global BigInt */
 function intIdentify(value) {
     return typeof value === 'bigint' || Number.isInteger(value);
 }
@@ -58,6 +57,6 @@ const jsonError = {
         return str;
     }
 };
-const json = [map, seq].concat(jsonScalars, jsonError);
+const schema = [map, seq].concat(jsonScalars, jsonError);
 
-export { json };
+export { schema };

package/browser/dist/schema/tags.js

@@ -0,0 +1,79 @@
+import { map } from './common/map.js';
+import { nullTag } from './common/null.js';
+import { seq } from './common/seq.js';
+import { string } from './common/string.js';
+import { boolTag } from './core/bool.js';
+import { float, floatExp, floatNaN } from './core/float.js';
+import { int, intHex, intOct } from './core/int.js';
+import { schema } from './core/schema.js';
+import { schema as schema$1 } from './json/schema.js';
+import { binary } from './yaml-1.1/binary.js';
+import { omap } from './yaml-1.1/omap.js';
+import { pairs } from './yaml-1.1/pairs.js';
+import { schema as schema$2 } from './yaml-1.1/schema.js';
+import { set } from './yaml-1.1/set.js';
+import { floatTime, intTime, timestamp } from './yaml-1.1/timestamp.js';
+
+const schemas = {
+    core: schema,
+    failsafe: [map, seq, string],
+    json: schema$1,
+    yaml11: schema$2,
+    'yaml-1.1': schema$2
+};
+const tagsByName = {
+    binary,
+    bool: boolTag,
+    float,
+    floatExp,
+    floatNaN,
+    floatTime,
+    int,
+    intHex,
+    intOct,
+    intTime,
+    map,
+    null: nullTag,
+    omap,
+    pairs,
+    seq,
+    set,
+    timestamp
+};
+const coreKnownTags = {
+    'tag:yaml.org,2002:binary': binary,
+    'tag:yaml.org,2002:omap': omap,
+    'tag:yaml.org,2002:pairs': pairs,
+    'tag:yaml.org,2002:set': set,
+    'tag:yaml.org,2002:timestamp': timestamp
+};
+function getTags(customTags, schemaName) {
+    let tags = schemas[schemaName];
+    if (!tags) {
+        const keys = Object.keys(schemas)
+            .filter(key => key !== 'yaml11')
+            .map(key => JSON.stringify(key))
+            .join(', ');
+        throw new Error(`Unknown schema "${schemaName}"; use one of ${keys}`);
+    }
+    if (Array.isArray(customTags)) {
+        for (const tag of customTags)
+            tags = tags.concat(tag);
+    }
+    else if (typeof customTags === 'function') {
+        tags = customTags(tags.slice());
+    }
+    return tags.map(tag => {
+        if (typeof tag !== 'string')
+            return tag;
+        const tagObj = tagsByName[tag];
+        if (tagObj)
+            return tagObj;
+        const keys = Object.keys(tagsByName)
+            .map(key => JSON.stringify(key))
+            .join(', ');
+        throw new Error(`Unknown custom tag "${tag}"; use one of ${keys}`);
+    });
+}
+
+export { coreKnownTags, getTags };

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

@@ -0,0 +1,26 @@
+import { Scalar } from '../../nodes/Scalar.js';
+
+function boolStringify({ value, source }, ctx) {
+    const boolObj = value ? trueTag : falseTag;
+    if (source && boolObj.test.test(source))
+        return source;
+    return value ? ctx.options.trueStr : ctx.options.falseStr;
+}
+const trueTag = {
+    identify: value => value === true,
+    default: true,
+    tag: 'tag:yaml.org,2002:bool',
+    test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/,
+    resolve: () => new Scalar(true),
+    stringify: boolStringify
+};
+const falseTag = {
+    identify: value => value === false,
+    default: true,
+    tag: 'tag:yaml.org,2002:bool',
+    test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/i,
+    resolve: () => new Scalar(false),
+    stringify: boolStringify
+};
+
+export { falseTag, trueTag };

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

@@ -0,0 +1,43 @@
+import { Scalar } from '../../nodes/Scalar.js';
+import { stringifyNumber } from '../../stringify/stringifyNumber.js';
+
+const floatNaN = {
+    identify: value => typeof value === 'number',
+    default: true,
+    tag: 'tag:yaml.org,2002:float',
+    test: /^[-+]?\.(?:inf|Inf|INF|nan|NaN|NAN)$/,
+    resolve: (str) => str.slice(-3).toLowerCase() === 'nan'
+        ? NaN
+        : str[0] === '-'
+            ? Number.NEGATIVE_INFINITY
+            : Number.POSITIVE_INFINITY,
+    stringify: stringifyNumber
+};
+const floatExp = {
+    identify: value => typeof value === 'number',
+    default: true,
+    tag: 'tag:yaml.org,2002:float',
+    format: 'EXP',
+    test: /^[-+]?(?:[0-9][0-9_]*)?(?:\.[0-9_]*)?[eE][-+]?[0-9]+$/,
+    resolve: (str) => parseFloat(str.replace(/_/g, '')),
+    stringify: ({ value }) => Number(value).toExponential()
+};
+const float = {
+    identify: value => typeof value === 'number',
+    default: true,
+    tag: 'tag:yaml.org,2002:float',
+    test: /^[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*$/,
+    resolve(str) {
+        const node = new Scalar(parseFloat(str.replace(/_/g, '')));
+        const dot = str.indexOf('.');
+        if (dot !== -1) {
+            const f = str.substring(dot + 1).replace(/_/g, '');
+            if (f[f.length - 1] === '0')
+                node.minFractionDigits = f.length;
+        }
+        return node;
+    },
+    stringify: stringifyNumber
+};
+
+export { float, floatExp, floatNaN };

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

@@ -0,0 +1,71 @@
+import { stringifyNumber } from '../../stringify/stringifyNumber.js';
+
+const intIdentify = (value) => typeof value === 'bigint' || Number.isInteger(value);
+function intResolve(str, offset, radix, { intAsBigInt }) {
+    const sign = str[0];
+    if (sign === '-' || sign === '+')
+        offset += 1;
+    str = str.substring(offset).replace(/_/g, '');
+    if (intAsBigInt) {
+        switch (radix) {
+            case 2:
+                str = `0b${str}`;
+                break;
+            case 8:
+                str = `0o${str}`;
+                break;
+            case 16:
+                str = `0x${str}`;
+                break;
+        }
+        const n = BigInt(str);
+        return sign === '-' ? BigInt(-1) * n : n;
+    }
+    const n = parseInt(str, radix);
+    return sign === '-' ? -1 * n : n;
+}
+function intStringify(node, radix, prefix) {
+    const { value } = node;
+    if (intIdentify(value)) {
+        const str = value.toString(radix);
+        return value < 0 ? '-' + prefix + str.substr(1) : prefix + str;
+    }
+    return stringifyNumber(node);
+}
+const intBin = {
+    identify: intIdentify,
+    default: true,
+    tag: 'tag:yaml.org,2002:int',
+    format: 'BIN',
+    test: /^[-+]?0b[0-1_]+$/,
+    resolve: (str, _onError, opt) => intResolve(str, 2, 2, opt),
+    stringify: node => intStringify(node, 2, '0b')
+};
+const intOct = {
+    identify: intIdentify,
+    default: true,
+    tag: 'tag:yaml.org,2002:int',
+    format: 'OCT',
+    test: /^[-+]?0[0-7_]+$/,
+    resolve: (str, _onError, opt) => intResolve(str, 1, 8, opt),
+    stringify: node => intStringify(node, 8, '0')
+};
+const int = {
+    identify: intIdentify,
+    default: true,
+    tag: 'tag:yaml.org,2002:int',
+    test: /^[-+]?[0-9][0-9_]*$/,
+    resolve: (str, _onError, opt) => intResolve(str, 0, 10, opt),
+    stringify: stringifyNumber
+};
+const intHex = {
+    identify: intIdentify,
+    default: true,
+    tag: 'tag:yaml.org,2002:int',
+    format: 'HEX',
+    test: /^[-+]?0x[0-9a-fA-F_]+$/,
+    resolve: (str, _onError, opt) => intResolve(str, 2, 16, opt),
+    stringify: node => intStringify(node, 16, '0x')
+};
+
+export { int, intBin, intHex, intOct };

package/browser/dist/{tags → schema}/yaml-1.1/pairs.js

@@ -1,5 +1,6 @@
 import { isSeq, isPair, isMap } from '../../nodes/Node.js';
 import { Pair, createPair } from '../../nodes/Pair.js';
+import { Scalar } from '../../nodes/Scalar.js';
 import { YAMLSeq } from '../../nodes/YAMLSeq.js';
 
 function resolvePairs(seq, onError) {
@@ -11,15 +12,17 @@ function resolvePairs(seq, onError) {
             else if (isMap(item)) {
                 if (item.items.length > 1)
                     onError('Each pair must have its own sequence indicator');
-                const pair = item.items[0] || new Pair(null);
+                const pair = item.items[0] || new Pair(new Scalar(null));
                 if (item.commentBefore)
-                    pair.commentBefore = pair.commentBefore
-                        ? `${item.commentBefore}\n${pair.commentBefore}`
+                    pair.key.commentBefore = pair.key.commentBefore
+                        ? `${item.commentBefore}\n${pair.key.commentBefore}`
                         : item.commentBefore;
-                if (item.comment)
-                    pair.comment = pair.comment
-                        ? `${item.comment}\n${pair.comment}`
+                if (item.comment) {
+                    const cn = pair.value || pair.key;
+                    cn.comment = cn.comment
+                        ? `${item.comment}\n${cn.comment}`
                         : item.comment;
+                }
                 item = pair;
             }
             seq.items[i] = isPair(item) ? item : new Pair(item);

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

@@ -0,0 +1,37 @@
+import { map } from '../common/map.js';
+import { nullTag } from '../common/null.js';
+import { seq } from '../common/seq.js';
+import { string } from '../common/string.js';
+import { binary } from './binary.js';
+import { trueTag, falseTag } from './bool.js';
+import { floatNaN, floatExp, float } from './float.js';
+import { intBin, intOct, int, intHex } from './int.js';
+import { omap } from './omap.js';
+import { pairs } from './pairs.js';
+import { set } from './set.js';
+import { intTime, floatTime, timestamp } from './timestamp.js';
+
+const schema = [
+    map,
+    seq,
+    string,
+    nullTag,
+    trueTag,
+    falseTag,
+    intBin,
+    intOct,
+    int,
+    intHex,
+    floatNaN,
+    floatExp,
+    float,
+    binary,
+    omap,
+    pairs,
+    set,
+    intTime,
+    floatTime,
+    timestamp
+];
+
+export { schema };

package/browser/dist/stringify/stringify.js

@@ -1,8 +1,9 @@
-import { isPair, isAlias, isNode, isScalar } from '../nodes/Node.js';
+import { anchorIsValid } from '../doc/anchors.js';
+import { isPair, isAlias, isNode, isScalar, isCollection } from '../nodes/Node.js';
 import { stringifyString } from './stringifyString.js';
 
 const createStringifyContext = (doc, options) => ({
-    anchors: Object.create(null),
+    anchors: new Set(),
     doc,
     indent: '',
     indentStep: typeof options.indent === 'number' ? ' '.repeat(options.indent) : '  ',
@@ -19,7 +20,8 @@ const createStringifyContext = (doc, options) => ({
         nullStr: 'null',
         simpleKeys: false,
         singleQuote: false,
-        trueStr: 'true'
+        trueStr: 'true',
+        verifyAliasOrder: true
     }, options)
 });
 function getTagObject(tags, item) {
@@ -50,9 +52,9 @@ function getTagObject(tags, item) {
 // needs to be called before value stringifier to allow for circular anchor refs
 function stringifyProps(node, tagObj, { anchors, doc }) {
     const props = [];
-    const anchor = doc.anchors.getName(node);
-    if (anchor) {
-        anchors[anchor] = node;
+    const anchor = (isScalar(node) || isCollection(node)) && node.anchor;
+    if (anchor && anchorIsValid(anchor)) {
+        anchors.add(anchor);
         props.push(`&${anchor}`);
     }
     if (node.tag) {