yaml 2.0.0-4 → 2.0.0-8

package/dist/stringify/stringifyString.js

@@ -1,7 +1,6 @@
 'use strict';
 
 var Scalar = require('../nodes/Scalar.js');
-var addComment = require('./addComment.js');
 var foldFlowLines = require('./foldFlowLines.js');
 
 const getFoldOptions = (ctx) => ({
@@ -144,70 +143,80 @@ function blockString({ comment, type, value }, ctx, onComment, onChompKeep) {
     }
     const indent = ctx.indent ||
         (ctx.forceBlockIndent || containsDocumentMarker(value) ? '  ' : '');
-    const indentSize = indent ? '2' : '1'; // root is at -1
     const literal = type === Scalar.Scalar.BLOCK_FOLDED
         ? false
         : type === Scalar.Scalar.BLOCK_LITERAL
             ? true
             : !lineLengthOverLimit(value, ctx.options.lineWidth, indent.length);
-    let header = literal ? '|' : '>';
     if (!value)
-        return header + '\n';
-    let wsStart = '';
-    let wsEnd = '';
-    value = value
-        .replace(/[\n\t ]*$/, ws => {
-        const n = ws.indexOf('\n');
-        if (n === -1) {
-            header += '-'; // strip
-        }
-        else if (value === ws || n !== ws.length - 1) {
-            header += '+'; // keep
-            if (onChompKeep)
-                onChompKeep();
-        }
-        wsEnd = ws.replace(/\n$/, '');
-        return '';
-    })
-        .replace(/^[\n ]*/, ws => {
-        if (ws.indexOf(' ') !== -1)
-            header += indentSize;
-        const m = ws.match(/ +$/);
-        if (m) {
-            wsStart = ws.slice(0, -m[0].length);
-            return m[0];
-        }
-        else {
-            wsStart = ws;
-            return '';
-        }
-    });
-    if (wsEnd)
-        wsEnd = wsEnd.replace(/\n+(?!\n|$)/g, `$&${indent}`);
-    if (wsStart)
-        wsStart = wsStart.replace(/\n+/g, `$&${indent}`);
+        return literal ? '|\n' : '>\n';
+    // determine chomping from whitespace at value end
+    let chomp;
+    let endStart;
+    for (endStart = value.length; endStart > 0; --endStart) {
+        const ch = value[endStart - 1];
+        if (ch !== '\n' && ch !== '\t' && ch !== ' ')
+            break;
+    }
+    let end = value.substring(endStart);
+    const endNlPos = end.indexOf('\n');
+    if (endNlPos === -1) {
+        chomp = '-'; // strip
+    }
+    else if (value === end || endNlPos !== end.length - 1) {
+        chomp = '+'; // keep
+        if (onChompKeep)
+            onChompKeep();
+    }
+    else {
+        chomp = ''; // clip
+    }
+    if (end) {
+        value = value.slice(0, -end.length);
+        if (end[end.length - 1] === '\n')
+            end = end.slice(0, -1);
+        end = end.replace(/\n+(?!\n|$)/g, `$&${indent}`);
+    }
+    // determine indent indicator from whitespace at value start
+    let startWithSpace = false;
+    let startEnd;
+    let startNlPos = -1;
+    for (startEnd = 0; startEnd < value.length; ++startEnd) {
+        const ch = value[startEnd];
+        if (ch === ' ')
+            startWithSpace = true;
+        else if (ch === '\n')
+            startNlPos = startEnd;
+        else
+            break;
+    }
+    let start = value.substring(0, startNlPos < startEnd ? startNlPos + 1 : startEnd);
+    if (start) {
+        value = value.substring(start.length);
+        start = start.replace(/\n+/g, `$&${indent}`);
+    }
+    const indentSize = indent ? '2' : '1'; // root is at -1
+    let header = (literal ? '|' : '>') + (startWithSpace ? indentSize : '') + chomp;
     if (comment) {
         header += ' #' + comment.replace(/ ?[\r\n]+/g, ' ');
         if (onComment)
             onComment();
     }
-    if (!value)
-        return `${header}${indentSize}\n${indent}${wsEnd}`;
     if (literal) {
         value = value.replace(/\n+/g, `$&${indent}`);
-        return `${header}\n${indent}${wsStart}${value}${wsEnd}`;
+        return `${header}\n${indent}${start}${value}${end}`;
     }
     value = value
         .replace(/\n+/g, '\n$&')
         .replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, '$1$2') // more-indented lines aren't folded
-        //         ^ ind.line  ^ empty     ^ capture next empty lines only at end of indent
+        //                ^ more-ind. ^ empty     ^ capture next empty lines only at end of indent
         .replace(/\n+/g, `$&${indent}`);
-    const body = foldFlowLines.foldFlowLines(`${wsStart}${value}${wsEnd}`, indent, foldFlowLines.FOLD_BLOCK, getFoldOptions(ctx));
+    const body = foldFlowLines.foldFlowLines(`${start}${value}${end}`, indent, foldFlowLines.FOLD_BLOCK, getFoldOptions(ctx));
     return `${header}\n${indent}${body}`;
 }
 function plainString(item, ctx, onComment, onChompKeep) {
     var _a;
-    const { comment, type, value } = item;
+    const { type, value } = item;
     const { actualString, implicitKey, indent, inFlow } = ctx;
     if ((implicitKey && /[\n[\]{},]/.test(value)) ||
         (inFlow && /[[\]{},]/.test(value))) {
@@ -263,17 +272,9 @@ function plainString(item, ctx, onComment, onChompKeep) {
                 return doubleQuotedString(value, ctx);
         }
     }
-    const body = implicitKey
+    return implicitKey
         ? str
         : foldFlowLines.foldFlowLines(str, indent, foldFlowLines.FOLD_FLOW, getFoldOptions(ctx));
-    if (comment &&
-        !inFlow &&
-        (body.indexOf('\n') !== -1 || comment.indexOf('\n') !== -1)) {
-        if (onComment)
-            onComment();
-        return addComment.addCommentBefore(body, indent, comment);
-    }
-    return body;
 }
 function stringifyString(item, ctx, onComment, onChompKeep) {
     const { implicitKey, inFlow } = ctx;

package/dist/test-events.d.ts

@@ -1,5 +1,4 @@
-import type { Options } from './options.js';
-export declare function testEvents(src: string, options?: Options): {
+export declare function testEvents(src: string): {
     events: string[];
     error: any;
 };

package/dist/test-events.js

@@ -2,6 +2,7 @@
 
 var Node = require('./nodes/Node.js');
 var publicApi = require('./public-api.js');
+var visit = require('./visit.js');
 
 const scalarChar = {
     BLOCK_FOLDED: '>',
@@ -10,11 +11,22 @@ const scalarChar = {
     QUOTE_DOUBLE: '"',
     QUOTE_SINGLE: "'"
 };
+function anchorExists(doc, anchor) {
+    let found = false;
+    visit.visit(doc, {
+        Value(_key, node) {
+            if (node.anchor === anchor) {
+                found = true;
+                return visit.visit.BREAK;
+            }
+        }
+    });
+    return found;
+}
 // test harness for yaml-test-suite event tests
-function testEvents(src, options) {
+function testEvents(src) {
     var _a;
-    const opt = Object.assign({ version: '1.2' }, options);
-    const docs = publicApi.parseAllDocuments(src, opt);
+    const docs = publicApi.parseAllDocuments(src);
     const errDoc = docs.find(doc => doc.errors.length > 0);
     const error = errDoc ? errDoc.errors[0].message : null;
     const events = ['+STR'];
@@ -24,17 +36,18 @@ function testEvents(src, options) {
             let root = doc.contents;
             if (Array.isArray(root))
                 root = root[0];
-            const [rootStart, rootEnd] = doc.range || [0, 0];
+            // eslint-disable-next-line no-sparse-arrays
+            const [rootStart, , rootEnd] = doc.range || [0, , 0];
             const error = doc.errors[0];
-            if (error && (!error.offset || error.offset < rootStart))
+            if (error && (!error.pos || error.pos[0] < rootStart))
                 throw new Error();
             let docStart = '+DOC';
             if (doc.directives.marker)
                 docStart += ' ---';
-            else if (doc.contents && doc.contents.range[1] === doc.contents.range[0])
+            else if (doc.contents && doc.contents.range[2] === doc.contents.range[0])
                 continue;
             events.push(docStart);
-            addEvents(events, doc, (_a = error === null || error === void 0 ? void 0 : error.offset) !== null && _a !== void 0 ? _a : -1, root);
+            addEvents(events, doc, (_a = error === null || error === void 0 ? void 0 : error.pos[0]) !== null && _a !== void 0 ? _a : -1, root);
             let docEnd = '-DOC';
             if (rootEnd) {
                 const post = src.slice(rootStart, rootEnd);
@@ -58,16 +71,16 @@ function addEvents(events, doc, errPos, node) {
     if (errPos !== -1 && Node.isNode(node) && node.range[0] >= errPos)
         throw new Error();
     let props = '';
-    let anchor = Node.isNode(node) ? doc.anchors.getName(node) : undefined;
+    let anchor = Node.isScalar(node) || Node.isCollection(node) ? node.anchor : undefined;
     if (anchor) {
         if (/\d$/.test(anchor)) {
             const alt = anchor.replace(/\d$/, '');
-            if (doc.anchors.getNode(alt))
+            if (anchorExists(doc, alt))
                 anchor = alt;
         }
         props = ` &${anchor}`;
     }
-    if (node.tag)
+    if (Node.isNode(node) && node.tag)
         props += ` <${node.tag}>`;
     if (Node.isMap(node)) {
         events.push(`+MAP${props}`);
@@ -91,10 +104,10 @@ function addEvents(events, doc, errPos, node) {
         events.push('-MAP');
     }
     else if (Node.isAlias(node)) {
-        let alias = doc.anchors.getName(node.source);
+        let alias = node.source;
         if (alias && /\d$/.test(alias)) {
             const alt = alias.replace(/\d$/, '');
-            if (doc.anchors.getNode(alt))
+            if (anchorExists(doc, alt))
                 alias = alt;
         }
         events.push(`=ALI${props} *${alias}`);

package/dist/util.d.ts

@@ -1,6 +1,6 @@
 export { debug, LogLevelId, warn } from './log.js';
 export { findPair } from './nodes/YAMLMap.js';
-export { toJS, ToJSAnchorValue, ToJSContext } from './nodes/toJS.js';
+export { toJS, ToJSContext } from './nodes/toJS.js';
 export { foldFlowLines } from './stringify/foldFlowLines';
 export { stringifyNumber } from './stringify/stringifyNumber.js';
 export { stringifyString } from './stringify/stringifyString.js';

package/dist/visit.d.ts

@@ -8,10 +8,13 @@ import type { YAMLSeq } from './nodes/YAMLSeq.js';
 export declare type visitorFn<T> = (key: number | 'key' | 'value' | null, node: T, path: readonly (Document | Node | Pair)[]) => void | symbol | number | Node | Pair;
 export declare type visitor = visitorFn<unknown> | {
     Alias?: visitorFn<Alias>;
+    Collection?: visitorFn<YAMLMap | YAMLSeq>;
     Map?: visitorFn<YAMLMap>;
+    Node?: visitorFn<Alias | Scalar | YAMLMap | YAMLSeq>;
     Pair?: visitorFn<Pair>;
     Scalar?: visitorFn<Scalar>;
     Seq?: visitorFn<YAMLSeq>;
+    Value?: visitorFn<Scalar | YAMLMap | YAMLSeq>;
 };
 /**
  * Apply a visitor to an AST node or document.
@@ -38,14 +41,20 @@ export declare type visitor = visitorFn<unknown> | {
  * If `visitor` is a single function, it will be called with all values
  * encountered in the tree, including e.g. `null` values. Alternatively,
  * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,
- * `Alias` and `Scalar` node.
+ * `Alias` and `Scalar` node. To define the same visitor function for more than
+ * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)
+ * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
+ * specific defined one will be used for each node.
  */
 export declare function visit(node: Node | Document | null, visitor: visitorFn<unknown> | {
     Alias?: visitorFn<Alias>;
+    Collection?: visitorFn<YAMLMap | YAMLSeq>;
     Map?: visitorFn<YAMLMap>;
+    Node?: visitorFn<Alias | Scalar | YAMLMap | YAMLSeq>;
     Pair?: visitorFn<Pair>;
     Scalar?: visitorFn<Scalar>;
     Seq?: visitorFn<YAMLSeq>;
+    Value?: visitorFn<Scalar | YAMLMap | YAMLSeq>;
 }): void;
 export declare namespace visit {
     var BREAK: symbol;

package/dist/visit.js

@@ -30,9 +30,28 @@ const REMOVE = Symbol('remove node');
  * If `visitor` is a single function, it will be called with all values
  * encountered in the tree, including e.g. `null` values. Alternatively,
  * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`,
- * `Alias` and `Scalar` node.
+ * `Alias` and `Scalar` node. To define the same visitor function for more than
+ * one node type, use the `Collection` (map and seq), `Value` (map, seq & scalar)
+ * and `Node` (alias, map, seq & scalar) targets. Of all these, only the most
+ * specific defined one will be used for each node.
  */
 function visit(node, visitor) {
+    if (typeof visitor === 'object' &&
+        (visitor.Collection || visitor.Node || visitor.Value)) {
+        visitor = Object.assign({
+            Alias: visitor.Node,
+            Map: visitor.Node,
+            Scalar: visitor.Node,
+            Seq: visitor.Node
+        }, visitor.Value && {
+            Map: visitor.Value,
+            Scalar: visitor.Value,
+            Seq: visitor.Value
+        }, visitor.Collection && {
+            Map: visitor.Collection,
+            Seq: visitor.Collection
+        }, visitor);
+    }
     if (Node.isDocument(node)) {
         const cd = _visit(null, node.contents, visitor, Object.freeze([node]));
         if (cd === REMOVE)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yaml",
-  "version": "2.0.0-4",
+  "version": "2.0.0-8",
   "license": "ISC",
   "author": "Eemeli Aro <eemeli@gmail.com>",
   "repository": "github:eemeli/yaml",
@@ -46,6 +46,7 @@
     "test": "jest --config config/jest.config.js",
     "test:browsers": "cd playground && npm test",
     "test:dist": "npm run build:node && jest --config config/jest.config.js",
+    "test:dist:types": "tsc --allowJs --moduleResolution node --noEmit --target es2017 dist/index.js",
     "test:types": "tsc --noEmit",
     "docs:install": "cd docs-slate && bundle install",
     "docs:deploy": "cd docs-slate && ./deploy.sh",
@@ -53,7 +54,7 @@
     "preversion": "npm test && npm run build",
     "prepublishOnly": "npm run clean && npm test && npm run build"
   },
-  "browserslist": "> 0.5%, not dead, not ie 11",
+  "browserslist": "defaults, not ie 11",
   "prettier": {
     "arrowParens": "avoid",
     "semi": false,
@@ -69,23 +70,23 @@
     "@rollup/plugin-babel": "^5.2.3",
     "@rollup/plugin-replace": "^2.3.4",
     "@rollup/plugin-typescript": "^8.1.1",
-    "@types/jest": "^26.0.20",
+    "@types/jest": "^27.0.1",
+    "@types/node": "^15.6.1",
     "@typescript-eslint/eslint-plugin": "^4.15.2",
     "@typescript-eslint/parser": "^4.15.2",
-    "babel-jest": "^26.6.3",
+    "babel-jest": "^27.0.1",
     "cross-env": "^7.0.3",
     "eslint": "^7.20.0",
     "eslint-config-prettier": "^8.1.0",
     "fast-check": "^2.12.0",
-    "jest": "^26.6.3",
+    "jest": "^27.0.1",
     "jest-ts-webcompat-resolver": "^1.0.0",
     "prettier": "^2.2.1",
     "rollup": "^2.38.2",
-    "rollup-plugin-copy": "^3.3.0",
     "tslib": "^2.1.0",
-    "typescript": "^4.1.3"
+    "typescript": "^4.3.5"
   },
   "engines": {
-    "node": ">= 10"
+    "node": ">= 12"
   }
 }

package/browser/dist/doc/Anchors.js

@@ -1,102 +0,0 @@
-import { Alias } from '../nodes/Alias.js';
-import { isAlias, isMap, isScalar, isCollection } from '../nodes/Node.js';
-import { Pair } from '../nodes/Pair.js';
-import { Scalar } from '../nodes/Scalar.js';
-import { YAMLSeq } from '../nodes/YAMLSeq.js';
-
-class Anchors {
-    constructor(prefix) {
-        this.map = Object.create(null);
-        this.prefix = prefix;
-    }
-    /**
-     * Create a new `Alias` node, adding the required anchor for `node`.
-     * If `name` is empty, a new anchor name will be generated.
-     */
-    createAlias(node, name) {
-        this.setAnchor(node, name);
-        return new Alias(node);
-    }
-    /**
-     * Create a new merge `Pair` with the given source nodes.
-     * Non-`Alias` sources will be automatically wrapped.
-     */
-    createMergePair(...sources) {
-        const key = new Scalar(Pair.MERGE_KEY);
-        const items = sources.map(s => {
-            if (isAlias(s)) {
-                if (isMap(s.source))
-                    return s;
-            }
-            else if (isMap(s)) {
-                return this.createAlias(s);
-            }
-            throw new Error('Merge sources must be Map nodes or their Aliases');
-        });
-        if (items.length === 1)
-            return new Pair(key, items[0]);
-        const seq = new YAMLSeq();
-        seq.items = items;
-        return new Pair(key, seq);
-    }
-    /** The anchor name associated with `node`, if set. */
-    getName(node) {
-        return Object.keys(this.map).find(a => this.map[a] === node);
-    }
-    /** List of all defined anchor names. */
-    getNames() {
-        return Object.keys(this.map);
-    }
-    /** The node associated with the anchor `name`, if set. */
-    getNode(name) {
-        return this.map[name];
-    }
-    /**
-     * Find an available anchor name with the given `prefix` and a
-     * numerical suffix.
-     */
-    newName(prefix) {
-        if (!prefix)
-            prefix = this.prefix;
-        const names = Object.keys(this.map);
-        for (let i = 1; true; ++i) {
-            const name = `${prefix}${i}`;
-            if (!names.includes(name))
-                return name;
-        }
-    }
-    /**
-     * Associate an anchor with `node`. If `name` is empty, a new name will be generated.
-     * To remove an anchor, use `setAnchor(null, name)`.
-     */
-    setAnchor(node, name) {
-        const { map } = this;
-        if (!node) {
-            if (!name)
-                return null;
-            delete map[name];
-            return name;
-        }
-        if (!isScalar(node) && !isCollection(node))
-            throw new Error('Anchors may only be set for Scalar, Seq and Map nodes');
-        if (name) {
-            if (/[\x00-\x19\s,[\]{}]/.test(name))
-                throw new Error('Anchor names must not contain whitespace or control characters');
-            const prevNode = map[name];
-            if (prevNode && prevNode !== node)
-                map[this.newName(name)] = prevNode;
-        }
-        const prevName = Object.keys(map).find(a => map[a] === node);
-        if (prevName) {
-            if (!name || prevName === name)
-                return prevName;
-            delete map[prevName];
-        }
-        else if (!name)
-            name = this.newName();
-        map[name] = node;
-        return name;
-    }
-}
-
-export { Anchors };

package/browser/dist/doc/Schema.js

@@ -1,27 +0,0 @@
-import { tags, schemas } from '../tags/index.js';
-import { getSchemaTags } from './getSchemaTags.js';
-
-const sortMapEntriesByKey = (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0;
-const coreKnownTags = {
-    'tag:yaml.org,2002:binary': tags.binary,
-    'tag:yaml.org,2002:omap': tags.omap,
-    'tag:yaml.org,2002:pairs': tags.pairs,
-    'tag:yaml.org,2002:set': tags.set,
-    'tag:yaml.org,2002:timestamp': tags.timestamp
-};
-class Schema {
-    constructor({ customTags, merge, resolveKnownTags, schema, sortMapEntries }) {
-        // Used by createNode(), to avoid circular dependencies
-        this.map = tags.map;
-        this.seq = tags.seq;
-        this.merge = !!merge;
-        this.name = schema || 'core';
-        this.knownTags = resolveKnownTags ? coreKnownTags : {};
-        this.tags = getSchemaTags(schemas, tags, customTags, this.name);
-        // Used by createMap()
-        this.sortMapEntries =
-            sortMapEntries === true ? sortMapEntriesByKey : sortMapEntries || null;
-    }
-}
-
-export { Schema };

package/browser/dist/doc/getSchemaTags.js

@@ -1,30 +0,0 @@
-function getSchemaTags(schemas, knownTags, customTags, schemaName) {
-    const schemaId = schemaName.replace(/\W/g, ''); // 'yaml-1.1' -> 'yaml11'
-    let tags = schemas[schemaId];
-    if (!tags) {
-        const keys = Object.keys(schemas)
-            .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 = knownTags[tag];
-        if (tagObj)
-            return tagObj;
-        const keys = Object.keys(knownTags)
-            .map(key => JSON.stringify(key))
-            .join(', ');
-        throw new Error(`Unknown custom tag "${tag}"; use one of ${keys}`);
-    });
-}
-
-export { getSchemaTags };

package/browser/dist/stringify/addComment.js

@@ -1,17 +0,0 @@
-function addCommentBefore(str, indent, comment) {
-    if (!comment)
-        return str;
-    const cc = comment.replace(/[\s\S]^/gm, `$&${indent}#`);
-    return `#${cc}\n${indent}${str}`;
-}
-function addComment(str, indent, comment) {
-    return !comment
-        ? str
-        : comment.includes('\n')
-            ? `${str}\n` + comment.replace(/^/gm, `${indent || ''}#`)
-            : str.endsWith(' ')
-                ? `${str}#${comment}`
-                : `${str} #${comment}`;
-}
-
-export { addComment, addCommentBefore };

package/browser/dist/tags/core.js

@@ -1,109 +0,0 @@
-import { Scalar } from '../nodes/Scalar.js';
-import { stringifyNumber } from '../stringify/stringifyNumber.js';
-import { failsafe } from './failsafe/index.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 nullObj = {
-    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 && nullObj.test.test(source) ? source : ctx.options.nullStr
-};
-const boolObj = {
-    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 && boolObj.test.test(source)) {
-            const sv = source[0] === 't' || source[0] === 'T';
-            if (value === sv)
-                return source;
-        }
-        return value ? ctx.options.trueStr : ctx.options.falseStr;
-    }
-};
-const octObj = {
-    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 intObj = {
-    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 hexObj = {
-    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')
-};
-const nanObj = {
-    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 expObj = {
-    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 floatObj = {
-    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
-};
-const core = failsafe.concat([
-    nullObj,
-    boolObj,
-    octObj,
-    intObj,
-    hexObj,
-    nanObj,
-    expObj,
-    floatObj
-]);
-
-export { boolObj, core, expObj, floatObj, hexObj, intObj, nanObj, nullObj, octObj };