yaml 2.0.0-4 → 2.0.0-8

package/dist/public-api.d.ts

@@ -2,7 +2,7 @@ import { Composer } from './compose/composer.js';
 import type { Reviver } from './doc/applyReviver.js';
 import { Document, Replacer } from './doc/Document.js';
 import type { ParsedNode } from './nodes/Node.js';
-import type { Options, ToJSOptions, ToStringOptions } from './options.js';
+import type { CreateNodeOptions, DocumentOptions, ParseOptions, SchemaOptions, ToJSOptions, ToStringOptions } from './options.js';
 export interface EmptyStream extends Array<Document.Parsed>, ReturnType<Composer['streamInfo']> {
     empty: true;
 }
@@ -15,9 +15,9 @@ export interface EmptyStream extends Array<Document.Parsed>, ReturnType<Composer
  *   EmptyStream and contain additional stream information. In
  *   TypeScript, you should use `'empty' in docs` as a type guard for it.
  */
-export declare function parseAllDocuments<T extends ParsedNode = ParsedNode>(source: string, options?: Options): Document.Parsed<T>[] | EmptyStream;
+export declare function parseAllDocuments<T extends ParsedNode = ParsedNode>(source: string, options?: ParseOptions & DocumentOptions & SchemaOptions): Document.Parsed<T>[] | EmptyStream;
 /** Parse an input string into a single YAML.Document */
-export declare function parseDocument<T extends ParsedNode = ParsedNode>(source: string, options?: Options): Document.Parsed<T>;
+export declare function parseDocument<T extends ParsedNode = ParsedNode>(source: string, options?: ParseOptions & DocumentOptions & SchemaOptions): Document.Parsed<T>;
 /**
  * Parse an input string into JavaScript.
  *
@@ -31,13 +31,13 @@ export declare function parseDocument<T extends ParsedNode = ParsedNode>(source:
  *   document, so Maps become objects, Sequences arrays, and scalars result in
  *   nulls, booleans, numbers and strings.
  */
-export declare function parse(src: string, options?: Options & ToJSOptions): any;
-export declare function parse(src: string, reviver: Reviver, options?: Options & ToJSOptions): any;
+export declare function parse(src: string, options?: ParseOptions & DocumentOptions & SchemaOptions & ToJSOptions): any;
+export declare function parse(src: string, reviver: Reviver, options?: ParseOptions & DocumentOptions & SchemaOptions & ToJSOptions): any;
 /**
  * Stringify a value as a YAML document.
  *
  * @param replacer - A replacer array or function, as in `JSON.stringify()`
  * @returns Will always include `\n` as the last character, as is expected of YAML documents.
  */
-export declare function stringify(value: any, options?: Options & ToStringOptions): string;
-export declare function stringify(value: any, replacer?: Replacer | null, options?: string | number | (Options & ToStringOptions)): string;
+export declare function stringify(value: any, options?: DocumentOptions & SchemaOptions & ParseOptions & CreateNodeOptions & ToStringOptions): string;
+export declare function stringify(value: any, replacer?: Replacer | null, options?: string | number | (DocumentOptions & SchemaOptions & ParseOptions & CreateNodeOptions & ToStringOptions)): string;

package/dist/public-api.js

@@ -23,13 +23,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$1 = new composer.Composer(doc => docs.push(doc), options);
-    const parser$1 = new parser.Parser(composer$1.next, lineCounter === null || lineCounter === void 0 ? void 0 : lineCounter.addNewLine);
-    parser$1.parse(source);
-    composer$1.end();
+    const parser$1 = new parser.Parser(lineCounter === null || lineCounter === void 0 ? void 0 : lineCounter.addNewLine);
+    const composer$1 = new composer.Composer(options);
+    const docs = Array.from(composer$1.compose(parser$1.parse(source)));
     if (prettyErrors && lineCounter)
         for (const doc of docs) {
             doc.errors.forEach(errors.prettifyError(source, lineCounter));
@@ -40,21 +38,20 @@ function parseAllDocuments(source, options) {
     return Object.assign([], { empty: true }, composer$1.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$1 = new parser.Parser(lineCounter === null || lineCounter === void 0 ? void 0 : lineCounter.addNewLine);
+    const composer$1 = new composer.Composer(options);
     // `doc` is always set by compose.end(true) at the very latest
     let doc = null;
-    const composer$1 = new composer.Composer(_doc => {
+    for (const _doc of composer$1.compose(parser$1.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 errors.YAMLParseError(_doc.range[0], errMsg));
+            doc.errors.push(new errors.YAMLParseError(_doc.range.slice(0, 2), 'MULTIPLE_DOCS', 'Source contains multiple documents; please use YAML.parseAllDocuments()'));
+            break;
         }
-    }, options);
-    const parser$1 = new parser.Parser(composer$1.next, lineCounter === null || lineCounter === void 0 ? void 0 : lineCounter.addNewLine);
-    parser$1.parse(source);
-    composer$1.end(true, source.length);
+    }
     if (prettyErrors && lineCounter) {
         doc.errors.forEach(errors.prettifyError(source, lineCounter));
         doc.warnings.forEach(errors.prettifyError(source, lineCounter));

package/dist/{doc → schema}/Schema.d.ts

@@ -1,6 +1,7 @@
+import { MAP, SCALAR, SEQ } from '../nodes/Node.js';
 import type { Pair } from '../nodes/Pair.js';
 import type { SchemaOptions } from '../options.js';
-import type { CollectionTag, ScalarTag } from '../tags/types.js';
+import type { CollectionTag, ScalarTag } from './types.js';
 export declare type SchemaName = 'core' | 'failsafe' | 'json' | 'yaml-1.1';
 export declare class Schema {
     knownTags: Record<string, CollectionTag | ScalarTag>;
@@ -8,7 +9,9 @@ export declare class Schema {
     name: SchemaName;
     sortMapEntries: ((a: Pair, b: Pair) => number) | null;
     tags: Array<CollectionTag | ScalarTag>;
-    map: CollectionTag;
-    seq: CollectionTag;
+    [MAP]: CollectionTag;
+    [SCALAR]: ScalarTag;
+    [SEQ]: CollectionTag;
     constructor({ customTags, merge, resolveKnownTags, schema, sortMapEntries }: SchemaOptions);
+    clone(): Schema;
 }

package/dist/schema/Schema.js

@@ -0,0 +1,30 @@
+'use strict';
+
+var Node = require('../nodes/Node.js');
+var map = require('./common/map.js');
+var seq = require('./common/seq.js');
+var string = require('./common/string.js');
+var tags = require('./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 ? tags.coreKnownTags : {};
+        this.tags = tags.getTags(customTags, this.name);
+        Object.defineProperty(this, Node.MAP, { value: map.map });
+        Object.defineProperty(this, Node.SCALAR, { value: string.string });
+        Object.defineProperty(this, Node.SEQ, { value: seq.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;
+    }
+}
+
+exports.Schema = Schema;

package/dist/schema/common/null.d.ts

@@ -0,0 +1,4 @@
+import type { ScalarTag } from '../types.js';
+export declare const nullTag: ScalarTag & {
+    test: RegExp;
+};

package/dist/schema/common/null.js

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

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

@@ -1,8 +1,8 @@
 'use strict';
 
+var createNode = require('../../doc/createNode.js');
 var Node = require('../../nodes/Node.js');
 var YAMLSeq = require('../../nodes/YAMLSeq.js');
-var createNode = require('../../doc/createNode.js');
 
 function createSeq(schema, obj, ctx) {
     const { replacer } = ctx;

package/dist/schema/core/bool.d.ts

@@ -0,0 +1,4 @@
+import type { ScalarTag } from '../types.js';
+export declare const boolTag: ScalarTag & {
+    test: RegExp;
+};

package/dist/schema/core/bool.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var Scalar = require('../../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.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;
+    }
+};
+
+exports.boolTag = boolTag;

package/dist/schema/core/float.d.ts

@@ -0,0 +1,4 @@
+import type { ScalarTag } from '../types.js';
+export declare const floatNaN: ScalarTag;
+export declare const floatExp: ScalarTag;
+export declare const float: ScalarTag;

package/dist/schema/core/float.js

@@ -0,0 +1,44 @@
+'use strict';
+
+var Scalar = require('../../nodes/Scalar.js');
+var stringifyNumber = require('../../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.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.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.stringifyNumber
+};
+
+exports.float = float;
+exports.floatExp = floatExp;
+exports.floatNaN = floatNaN;

package/dist/schema/core/int.d.ts

@@ -0,0 +1,4 @@
+import type { ScalarTag } from '../types.js';
+export declare const intOct: ScalarTag;
+export declare const int: ScalarTag;
+export declare const intHex: ScalarTag;

package/dist/schema/core/int.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var stringifyNumber = require('../../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.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.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')
+};
+
+exports.int = int;
+exports.intHex = intHex;
+exports.intOct = intOct;

package/dist/schema/core/schema.d.ts

@@ -0,0 +1 @@
+export declare const schema: (import("../types.js").ScalarTag | import("../types.js").CollectionTag)[];

package/dist/schema/core/schema.js

@@ -0,0 +1,25 @@
+'use strict';
+
+var map = require('../common/map.js');
+var _null = require('../common/null.js');
+var seq = require('../common/seq.js');
+var string = require('../common/string.js');
+var bool = require('./bool.js');
+var float = require('./float.js');
+var int = require('./int.js');
+
+const schema = [
+    map.map,
+    seq.seq,
+    string.string,
+    _null.nullTag,
+    bool.boolTag,
+    int.intOct,
+    int.int,
+    int.intHex,
+    float.floatNaN,
+    float.floatExp,
+    float.float
+];
+
+exports.schema = schema;

package/dist/schema/json/schema.d.ts

@@ -0,0 +1,2 @@
+import { CollectionTag, ScalarTag } from '../types.js';
+export declare const schema: (ScalarTag | CollectionTag)[];

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

@@ -1,10 +1,9 @@
 'use strict';
 
-var Scalar = require('../nodes/Scalar.js');
-var map = require('./failsafe/map.js');
-var seq = require('./failsafe/seq.js');
+var Scalar = require('../../nodes/Scalar.js');
+var map = require('../common/map.js');
+var seq = require('../common/seq.js');
 
-/* global BigInt */
 function intIdentify(value) {
     return typeof value === 'bigint' || Number.isInteger(value);
 }
@@ -60,6 +59,6 @@ const jsonError = {
         return str;
     }
 };
-const json = [map.map, seq.seq].concat(jsonScalars, jsonError);
+const schema = [map.map, seq.seq].concat(jsonScalars, jsonError);
 
-exports.json = json;
+exports.schema = schema;

package/dist/schema/tags.d.ts

@@ -0,0 +1,41 @@
+import { SchemaOptions } from '../options.js';
+import type { SchemaName } from './Schema.js';
+import type { CollectionTag, ScalarTag } from './types.js';
+declare const tagsByName: {
+    binary: ScalarTag;
+    bool: ScalarTag & {
+        test: RegExp;
+    };
+    float: ScalarTag;
+    floatExp: ScalarTag;
+    floatNaN: ScalarTag;
+    floatTime: ScalarTag;
+    int: ScalarTag;
+    intHex: ScalarTag;
+    intOct: ScalarTag;
+    intTime: ScalarTag;
+    map: CollectionTag;
+    null: ScalarTag & {
+        test: RegExp;
+    };
+    omap: CollectionTag;
+    pairs: CollectionTag;
+    seq: CollectionTag;
+    set: CollectionTag;
+    timestamp: ScalarTag & {
+        test: RegExp;
+    };
+};
+export declare type TagId = keyof typeof tagsByName;
+export declare type Tags = Array<ScalarTag | CollectionTag | TagId>;
+export declare const coreKnownTags: {
+    'tag:yaml.org,2002:binary': ScalarTag;
+    'tag:yaml.org,2002:omap': CollectionTag;
+    'tag:yaml.org,2002:pairs': CollectionTag;
+    'tag:yaml.org,2002:set': CollectionTag;
+    'tag:yaml.org,2002:timestamp': ScalarTag & {
+        test: RegExp;
+    };
+};
+export declare function getTags(customTags: SchemaOptions['customTags'] | undefined, schemaName: SchemaName): (ScalarTag | CollectionTag)[];
+export {};

package/dist/schema/tags.js

@@ -0,0 +1,82 @@
+'use strict';
+
+var map = require('./common/map.js');
+var _null = require('./common/null.js');
+var seq = require('./common/seq.js');
+var string = require('./common/string.js');
+var bool = require('./core/bool.js');
+var float = require('./core/float.js');
+var int = require('./core/int.js');
+var schema = require('./core/schema.js');
+var schema$1 = require('./json/schema.js');
+var binary = require('./yaml-1.1/binary.js');
+var omap = require('./yaml-1.1/omap.js');
+var pairs = require('./yaml-1.1/pairs.js');
+var schema$2 = require('./yaml-1.1/schema.js');
+var set = require('./yaml-1.1/set.js');
+var timestamp = require('./yaml-1.1/timestamp.js');
+
+const schemas = {
+    core: schema.schema,
+    failsafe: [map.map, seq.seq, string.string],
+    json: schema$1.schema,
+    yaml11: schema$2.schema,
+    'yaml-1.1': schema$2.schema
+};
+const tagsByName = {
+    binary: binary.binary,
+    bool: bool.boolTag,
+    float: float.float,
+    floatExp: float.floatExp,
+    floatNaN: float.floatNaN,
+    floatTime: timestamp.floatTime,
+    int: int.int,
+    intHex: int.intHex,
+    intOct: int.intOct,
+    intTime: timestamp.intTime,
+    map: map.map,
+    null: _null.nullTag,
+    omap: omap.omap,
+    pairs: pairs.pairs,
+    seq: seq.seq,
+    set: set.set,
+    timestamp: timestamp.timestamp
+};
+const coreKnownTags = {
+    'tag:yaml.org,2002:binary': binary.binary,
+    'tag:yaml.org,2002:omap': omap.omap,
+    'tag:yaml.org,2002:pairs': pairs.pairs,
+    'tag:yaml.org,2002:set': set.set,
+    'tag:yaml.org,2002:timestamp': 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}`);
+    });
+}
+
+exports.coreKnownTags = coreKnownTags;
+exports.getTags = getTags;

package/dist/{tags → schema}/types.d.ts

@@ -1,13 +1,11 @@
 import type { CreateNodeContext } from '../doc/createNode.js';
-import type { Schema } from '../doc/Schema.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 { ParseOptions } from '../options.js';
+import type { ParseOptions } from '../options.js';
 import type { StringifyContext } from '../stringify/stringify.js';
-export declare type SchemaId = 'core' | 'failsafe' | 'json' | 'yaml11';
-export declare type TagId = 'binary' | 'bool' | 'float' | 'floatExp' | 'floatNaN' | 'floatTime' | 'int' | 'intHex' | 'intOct' | 'intTime' | 'null' | 'omap' | 'pairs' | 'set' | 'timestamp';
 interface TagBase {
     /**
      * An optional factory function, used e.g. by collections when wrapping JS objects as AST nodes.
@@ -79,8 +77,6 @@ export interface CollectionTag extends TagBase {
      * Turns a value into an AST node.
      * If returning a non-`Node` value, the output will be wrapped as a `Scalar`.
      */
-    resolve(value: YAMLMap | YAMLSeq, onError: (message: string) => void, options: ParseOptions): unknown;
+    resolve(value: YAMLMap.Parsed | YAMLSeq.Parsed, onError: (message: string) => void, options: ParseOptions): unknown;
 }
-export declare type TagObj = ScalarTag | CollectionTag;
-export declare type TagValue = TagId | ScalarTag | CollectionTag;
 export {};

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

@@ -0,0 +1,7 @@
+import type { ScalarTag } from '../types.js';
+export declare const trueTag: ScalarTag & {
+    test: RegExp;
+};
+export declare const falseTag: ScalarTag & {
+    test: RegExp;
+};

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

@@ -0,0 +1,29 @@
+'use strict';
+
+var Scalar = require('../../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.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.Scalar(false),
+    stringify: boolStringify
+};
+
+exports.falseTag = falseTag;
+exports.trueTag = trueTag;

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

@@ -0,0 +1,4 @@
+import type { ScalarTag } from '../types.js';
+export declare const floatNaN: ScalarTag;
+export declare const floatExp: ScalarTag;
+export declare const float: ScalarTag;

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

@@ -0,0 +1,47 @@
+'use strict';
+
+var Scalar = require('../../nodes/Scalar.js');
+var stringifyNumber = require('../../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.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.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.stringifyNumber
+};
+
+exports.float = float;
+exports.floatExp = floatExp;
+exports.floatNaN = floatNaN;

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

@@ -0,0 +1,5 @@
+import type { ScalarTag } from '../types.js';
+export declare const intBin: ScalarTag;
+export declare const intOct: ScalarTag;
+export declare const int: ScalarTag;
+export declare const intHex: ScalarTag;