yaml 2.0.0-0 → 2.0.0-1

package/dist/{Schema-fe1471c4.js → Schema-807430ba.js}

@@ -1,18 +1,89 @@
 'use strict';
 
-var PlainValue = require('./PlainValue-ec8e588e.js');
-var resolveSeq = require('./resolveSeq-6b2dc4ac.js');
+var _rollupPluginBabelHelpers = require('./_rollupPluginBabelHelpers-eed30217.js');
+var stringifyNumber = require('./stringifyNumber-dea1120c.js');
+
+const MERGE_KEY = '<<';
+class Merge extends stringifyNumber.Pair {
+  constructor(pair) {
+    if (pair instanceof stringifyNumber.Pair) {
+      let seq = pair.value;
+
+      if (!(seq instanceof stringifyNumber.YAMLSeq)) {
+        seq = new stringifyNumber.YAMLSeq();
+        seq.items.push(pair.value);
+        seq.range = pair.value.range;
+      }
+
+      super(pair.key, seq);
+      this.range = pair.range;
+    } else {
+      super(new stringifyNumber.Scalar(MERGE_KEY), new stringifyNumber.YAMLSeq());
+    }
+
+    this.type = stringifyNumber.Pair.Type.MERGE_PAIR;
+  } // If the value associated with a merge key is a single mapping node, each of
+  // its key/value pairs is inserted into the current mapping, unless the key
+  // already exists in it. If the value associated with the merge key is a
+  // sequence, then this sequence is expected to contain mapping nodes and each
+  // of these nodes is merged in turn according to its order in the sequence.
+  // Keys in mapping nodes earlier in the sequence override keys specified in
+  // later mapping nodes. -- http://yaml.org/type/merge.html
+
+
+  addToJSMap(ctx, map) {
+    for (const {
+      source
+    } of this.value.items) {
+      if (!(source instanceof stringifyNumber.YAMLMap)) throw new Error('Merge sources must be maps');
+      const srcMap = source.toJSON(null, ctx, Map);
+
+      for (const [key, value] of srcMap) {
+        if (map instanceof Map) {
+          if (!map.has(key)) map.set(key, value);
+        } else if (map instanceof Set) {
+          map.add(key);
+        } else if (!Object.prototype.hasOwnProperty.call(map, key)) {
+          Object.defineProperty(map, key, {
+            value,
+            writable: true,
+            enumerable: true,
+            configurable: true
+          });
+        }
+      }
+    }
+
+    return map;
+  }
+
+  toString(ctx, onComment) {
+    const seq = this.value;
+    if (seq.items.length > 1) return super.toString(ctx, onComment);
+    this.value = seq.items[0];
+    const str = super.toString(ctx, onComment);
+    this.value = seq;
+    return str;
+  }
+
+}
 
 function createMap(schema, obj, ctx) {
-  const map = new resolveSeq.YAMLMap(schema);
+  const {
+    keepUndefined,
+    replacer
+  } = ctx;
+  const map = new stringifyNumber.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(stringifyNumber.createPair(key, value, ctx));
+  };
 
   if (obj instanceof Map) {
-    for (const [key, value] of obj) map.items.push(resolveSeq.createPair(key, value, ctx));
+    for (const [key, value] of obj) add(key, value);
   } else if (obj && typeof obj === 'object') {
-    for (const key of Object.keys(obj)) {
-      const value = obj[key];
-      if (value !== undefined) map.items.push(resolveSeq.createPair(key, value, ctx));
-    }
+    for (const key of Object.keys(obj)) add(key, obj[key]);
   }
 
   if (typeof schema.sortMapEntries === 'function') {
@@ -25,16 +96,28 @@ function createMap(schema, obj, ctx) {
 const map = {
   createNode: createMap,
   default: true,
-  nodeClass: resolveSeq.YAMLMap,
+  nodeClass: stringifyNumber.YAMLMap,
   tag: 'tag:yaml.org,2002:map',
-  resolve: resolveSeq.resolveMap
+  resolve: map => map
 };
 
 function createSeq(schema, obj, ctx) {
-  const seq = new resolveSeq.YAMLSeq(schema);
+  const {
+    replacer
+  } = ctx;
+  const seq = new stringifyNumber.YAMLSeq(schema);
 
   if (obj && obj[Symbol.iterator]) {
-    for (const it of obj) seq.items.push(resolveSeq.createNode(it, null, ctx));
+    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(stringifyNumber.createNode(it, null, ctx));
+    }
   }
 
   return seq;
@@ -43,25 +126,25 @@ function createSeq(schema, obj, ctx) {
 const seq = {
   createNode: createSeq,
   default: true,
-  nodeClass: resolveSeq.YAMLSeq,
+  nodeClass: stringifyNumber.YAMLSeq,
   tag: 'tag:yaml.org,2002:seq',
-  resolve: resolveSeq.resolveSeq
+  resolve: seq => seq
 };
 
 const string = {
   identify: value => typeof value === 'string',
   default: true,
   tag: 'tag:yaml.org,2002:str',
-  resolve: resolveSeq.resolveString,
+  resolve: str => str,
 
   stringify(item, ctx, onComment, onChompKeep) {
     ctx = Object.assign({
       actualString: true
     }, ctx);
-    return resolveSeq.stringifyString(item, ctx, onComment, onChompKeep);
+    return stringifyNumber.stringifyString(item, ctx, onComment, onChompKeep);
   },
 
-  options: resolveSeq.strOptions
+  options: stringifyNumber.strOptions
 };
 
 const failsafe = [map, seq, string];
@@ -70,25 +153,31 @@ const failsafe = [map, seq, string];
 
 const intIdentify = value => typeof value === 'bigint' || Number.isInteger(value);
 
-const intResolve = (src, part, radix) => resolveSeq.intOptions.asBigInt ? BigInt(src) : parseInt(part, radix);
+const intResolve = (src, offset, radix) => stringifyNumber.intOptions.asBigInt ? BigInt(src) : parseInt(src.substring(offset), radix);
 
 function intStringify(node, radix, prefix) {
   const {
     value
   } = node;
   if (intIdentify(value) && value >= 0) return prefix + value.toString(radix);
-  return resolveSeq.stringifyNumber(node);
+  return stringifyNumber.stringifyNumber(node);
 }
 
 const nullObj = {
   identify: value => value == null,
-  createNode: (schema, value, ctx) => ctx.wrapScalars ? new resolveSeq.Scalar(null) : null,
+  createNode: (schema, value, ctx) => ctx.wrapScalars ? new stringifyNumber.Scalar(null) : null,
   default: true,
   tag: 'tag:yaml.org,2002:null',
   test: /^(?:~|[Nn]ull|NULL)?$/,
-  resolve: () => null,
-  options: resolveSeq.nullOptions,
-  stringify: () => resolveSeq.nullOptions.nullStr
+  resolve: str => {
+    const node = new stringifyNumber.Scalar(null);
+    node.sourceStr = str;
+    return node;
+  },
+  options: stringifyNumber.nullOptions,
+  stringify: ({
+    sourceStr
+  }) => sourceStr !== null && sourceStr !== void 0 ? sourceStr : stringifyNumber.nullOptions.nullStr
 };
 const boolObj = {
   identify: value => typeof value === 'boolean',
@@ -96,19 +185,19 @@ const boolObj = {
   tag: 'tag:yaml.org,2002:bool',
   test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
   resolve: str => str[0] === 't' || str[0] === 'T',
-  options: resolveSeq.boolOptions,
+  options: stringifyNumber.boolOptions,
   stringify: ({
     value
-  }) => value ? resolveSeq.boolOptions.trueStr : resolveSeq.boolOptions.falseStr
+  }) => value ? stringifyNumber.boolOptions.trueStr : stringifyNumber.boolOptions.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, oct) => intResolve(str, oct, 8),
-  options: resolveSeq.intOptions,
+  test: /^0o[0-7]+$/,
+  resolve: str => intResolve(str, 2, 8),
+  options: stringifyNumber.intOptions,
   stringify: node => intStringify(node, 8, '0o')
 };
 const intObj = {
@@ -116,27 +205,27 @@ const intObj = {
   default: true,
   tag: 'tag:yaml.org,2002:int',
   test: /^[-+]?[0-9]+$/,
-  resolve: str => intResolve(str, str, 10),
-  options: resolveSeq.intOptions,
-  stringify: resolveSeq.stringifyNumber
+  resolve: str => intResolve(str, 0, 10),
+  options: stringifyNumber.intOptions,
+  stringify: stringifyNumber.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, hex) => intResolve(str, hex, 16),
-  options: resolveSeq.intOptions,
+  test: /^0x[0-9a-fA-F]+$/,
+  resolve: str => intResolve(str, 2, 16),
+  options: stringifyNumber.intOptions,
   stringify: node => intStringify(node, 16, '0x')
 };
 const nanObj = {
   identify: value => typeof value === 'number',
   default: true,
   tag: 'tag:yaml.org,2002:float',
-  test: /^(?:[-+]?\.inf|(\.nan))$/i,
-  resolve: (str, nan) => nan ? NaN : str[0] === '-' ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
-  stringify: resolveSeq.stringifyNumber
+  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 expObj = {
   identify: value => typeof value === 'number',
@@ -153,16 +242,16 @@ const floatObj = {
   identify: value => typeof value === 'number',
   default: true,
   tag: 'tag:yaml.org,2002:float',
-  test: /^[-+]?(?:\.([0-9]+)|[0-9]+\.([0-9]*))$/,
+  test: /^[-+]?(?:\.[0-9]+|[0-9]+\.[0-9]*)$/,
 
-  resolve(str, frac1, frac2) {
-    const frac = frac1 || frac2;
-    const node = new resolveSeq.Scalar(parseFloat(str));
-    if (frac && frac[frac.length - 1] === '0') node.minFractionDigits = frac.length;
+  resolve(str) {
+    const node = new stringifyNumber.Scalar(parseFloat(str));
+    const dot = str.indexOf('.');
+    if (dot !== -1 && str[str.length - 1] === '0') node.minFractionDigits = str.length - dot - 1;
     return node;
   },
 
-  stringify: resolveSeq.stringifyNumber
+  stringify: stringifyNumber.stringifyNumber
 };
 const core = failsafe.concat([nullObj, boolObj, octObj, intObj, hexObj, nanObj, expObj, floatObj]);
 
@@ -178,11 +267,11 @@ const json = [map, seq, {
   identify: value => typeof value === 'string',
   default: true,
   tag: 'tag:yaml.org,2002:str',
-  resolve: resolveSeq.resolveString,
+  resolve: str => str,
   stringify: stringifyJSON
 }, {
   identify: value => value == null,
-  createNode: (schema, value, ctx) => ctx.wrapScalars ? new resolveSeq.Scalar(null) : null,
+  createNode: (schema, value, ctx) => ctx.wrapScalars ? new stringifyNumber.Scalar(null) : null,
   default: true,
   tag: 'tag:yaml.org,2002:null',
   test: /^null$/,
@@ -200,7 +289,7 @@ const json = [map, seq, {
   default: true,
   tag: 'tag:yaml.org,2002:int',
   test: /^-?(?:0|[1-9][0-9]*)$/,
-  resolve: str => resolveSeq.intOptions.asBigInt ? BigInt(str) : parseInt(str, 10),
+  resolve: str => stringifyNumber.intOptions.asBigInt ? BigInt(str) : parseInt(str, 10),
   stringify: ({
     value
   }) => intIdentify$1(value) ? value.toString() : JSON.stringify(value)
@@ -211,11 +300,16 @@ const json = [map, seq, {
   test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,
   resolve: str => parseFloat(str),
   stringify: stringifyJSON
-}];
+}, {
+  default: true,
+  test: /^/,
 
-json.scalarFallback = str => {
-  throw new SyntaxError(`Unresolved plain scalar ${JSON.stringify(str)}`);
-};
+  resolve(str, onError) {
+    onError(`Unresolved plain scalar ${JSON.stringify(str)}`);
+    return str;
+  }
+
+}];
 
 /* global atob, btoa, Buffer */
 const binary = {
@@ -232,9 +326,7 @@ const binary = {
    *   const blob = new Blob([buffer], { type: 'image/jpeg' })
    *   document.querySelector('#photo').src = URL.createObjectURL(blob)
    */
-  resolve: (doc, node) => {
-    const src = resolveSeq.resolveString(doc, node);
-
+  resolve(src, onError) {
     if (typeof Buffer === 'function') {
       return Buffer.from(src, 'base64');
     } else if (typeof atob === 'function') {
@@ -246,12 +338,12 @@ const binary = {
 
       return buffer;
     } else {
-      const msg = 'This environment does not support reading binary tags; either Buffer or atob is required';
-      doc.errors.push(new PlainValue.YAMLReferenceError(node, msg));
-      return null;
+      onError('This environment does not support reading binary tags; either Buffer or atob is required');
+      return src;
     }
   },
-  options: resolveSeq.binaryOptions,
+
+  options: stringifyNumber.binaryOptions,
   stringify: ({
     comment,
     type,
@@ -271,14 +363,14 @@ const binary = {
       throw new Error('This environment does not support writing binary tags; either Buffer or btoa is required');
     }
 
-    if (!type) type = resolveSeq.binaryOptions.defaultType;
+    if (!type) type = stringifyNumber.binaryOptions.defaultType;
 
-    if (type === PlainValue.Type.QUOTE_DOUBLE) {
+    if (type === _rollupPluginBabelHelpers.Type.QUOTE_DOUBLE) {
       value = src;
     } else {
       const {
         lineWidth
-      } = resolveSeq.binaryOptions;
+      } = stringifyNumber.binaryOptions;
       const n = Math.ceil(src.length / lineWidth);
       const lines = new Array(n);
 
@@ -286,10 +378,10 @@ const binary = {
         lines[i] = src.substr(o, lineWidth);
       }
 
-      value = lines.join(type === PlainValue.Type.BLOCK_LITERAL ? '\n' : ' ');
+      value = lines.join(type === _rollupPluginBabelHelpers.Type.BLOCK_LITERAL ? '\n' : ' ');
     }
 
-    return resolveSeq.stringifyString({
+    return stringifyNumber.stringifyString({
       comment,
       type,
       value
@@ -297,32 +389,33 @@ const binary = {
   }
 };
 
-function parsePairs(doc, cst) {
-  const seq = resolveSeq.resolveSeq(doc, cst);
-
-  for (let i = 0; i < seq.items.length; ++i) {
-    let item = seq.items[i];
-    if (item instanceof resolveSeq.Pair) continue;else if (item instanceof resolveSeq.YAMLMap) {
-      if (item.items.length > 1) {
-        const msg = 'Each pair must have its own sequence indicator';
-        throw new PlainValue.YAMLSemanticError(cst, msg);
+function parsePairs(seq, onError) {
+  if (seq instanceof stringifyNumber.YAMLSeq) {
+    for (let i = 0; i < seq.items.length; ++i) {
+      let item = seq.items[i];
+      if (item instanceof stringifyNumber.Pair) continue;else if (item instanceof stringifyNumber.YAMLMap) {
+        if (item.items.length > 1) onError('Each pair must have its own sequence indicator');
+        const pair = item.items[0] || new stringifyNumber.Pair();
+        if (item.commentBefore) pair.commentBefore = pair.commentBefore ? `${item.commentBefore}\n${pair.commentBefore}` : item.commentBefore;
+        if (item.comment) pair.comment = pair.comment ? `${item.comment}\n${pair.comment}` : item.comment;
+        item = pair;
       }
-
-      const pair = item.items[0] || new resolveSeq.Pair();
-      if (item.commentBefore) pair.commentBefore = pair.commentBefore ? `${item.commentBefore}\n${pair.commentBefore}` : item.commentBefore;
-      if (item.comment) pair.comment = pair.comment ? `${item.comment}\n${pair.comment}` : item.comment;
-      item = pair;
+      seq.items[i] = item instanceof stringifyNumber.Pair ? item : new stringifyNumber.Pair(item);
     }
-    seq.items[i] = item instanceof resolveSeq.Pair ? item : new resolveSeq.Pair(item);
-  }
+  } else onError('Expected a sequence for this tag');
 
   return seq;
 }
 function createPairs(schema, iterable, ctx) {
-  const pairs = new resolveSeq.YAMLSeq(schema);
+  const {
+    replacer
+  } = ctx;
+  const pairs = new stringifyNumber.YAMLSeq(schema);
   pairs.tag = 'tag:yaml.org,2002:pairs';
+  let i = 0;
 
-  for (const it of iterable) {
+  for (let it of iterable) {
+    if (typeof replacer === 'function') it = replacer.call(iterable, String(i++), it);
     let key, value;
 
     if (Array.isArray(it)) {
@@ -341,7 +434,7 @@ function createPairs(schema, iterable, ctx) {
       key = it;
     }
 
-    pairs.items.push(resolveSeq.createPair(key, value, ctx));
+    pairs.items.push(stringifyNumber.createPair(key, value, ctx));
   }
 
   return pairs;
@@ -353,19 +446,19 @@ const pairs = {
   createNode: createPairs
 };
 
-class YAMLOMap extends resolveSeq.YAMLSeq {
+class YAMLOMap extends stringifyNumber.YAMLSeq {
   constructor() {
     super();
 
-    PlainValue._defineProperty(this, "add", resolveSeq.YAMLMap.prototype.add.bind(this));
+    _rollupPluginBabelHelpers._defineProperty(this, "add", stringifyNumber.YAMLMap.prototype.add.bind(this));
 
-    PlainValue._defineProperty(this, "delete", resolveSeq.YAMLMap.prototype.delete.bind(this));
+    _rollupPluginBabelHelpers._defineProperty(this, "delete", stringifyNumber.YAMLMap.prototype.delete.bind(this));
 
-    PlainValue._defineProperty(this, "get", resolveSeq.YAMLMap.prototype.get.bind(this));
+    _rollupPluginBabelHelpers._defineProperty(this, "get", stringifyNumber.YAMLMap.prototype.get.bind(this));
 
-    PlainValue._defineProperty(this, "has", resolveSeq.YAMLMap.prototype.has.bind(this));
+    _rollupPluginBabelHelpers._defineProperty(this, "has", stringifyNumber.YAMLMap.prototype.has.bind(this));
 
-    PlainValue._defineProperty(this, "set", resolveSeq.YAMLMap.prototype.set.bind(this));
+    _rollupPluginBabelHelpers._defineProperty(this, "set", stringifyNumber.YAMLMap.prototype.set.bind(this));
 
     this.tag = YAMLOMap.tag;
   }
@@ -377,11 +470,11 @@ class YAMLOMap extends resolveSeq.YAMLSeq {
     for (const pair of this.items) {
       let key, value;
 
-      if (pair instanceof resolveSeq.Pair) {
-        key = resolveSeq.toJSON(pair.key, '', ctx);
-        value = resolveSeq.toJSON(pair.value, key, ctx);
+      if (pair instanceof stringifyNumber.Pair) {
+        key = stringifyNumber.toJS(pair.key, '', ctx);
+        value = stringifyNumber.toJS(pair.value, key, ctx);
       } else {
-        key = resolveSeq.toJSON(pair, '', ctx);
+        key = stringifyNumber.toJS(pair, '', ctx);
       }
 
       if (map.has(key)) throw new Error('Ordered maps must not include duplicate keys');
@@ -393,19 +486,18 @@ class YAMLOMap extends resolveSeq.YAMLSeq {
 
 }
 
-PlainValue._defineProperty(YAMLOMap, "tag", 'tag:yaml.org,2002:omap');
+_rollupPluginBabelHelpers._defineProperty(YAMLOMap, "tag", 'tag:yaml.org,2002:omap');
 
-function parseOMap(doc, cst) {
-  const pairs = parsePairs(doc, cst);
+function parseOMap(seq, onError) {
+  const pairs = parsePairs(seq, onError);
   const seenKeys = [];
 
   for (const {
     key
   } of pairs.items) {
-    if (key instanceof resolveSeq.Scalar) {
+    if (key instanceof stringifyNumber.Scalar) {
       if (seenKeys.includes(key.value)) {
-        const msg = 'Ordered maps must not include duplicate keys';
-        throw new PlainValue.YAMLSemanticError(cst, msg);
+        onError(`Ordered maps must not include duplicate keys: ${key.value}`);
       } else {
         seenKeys.push(key.value);
       }
@@ -431,31 +523,31 @@ const omap = {
   createNode: createOMap
 };
 
-class YAMLSet extends resolveSeq.YAMLMap {
-  constructor() {
-    super();
+class YAMLSet extends stringifyNumber.YAMLMap {
+  constructor(schema) {
+    super(schema);
     this.tag = YAMLSet.tag;
   }
 
   add(key) {
-    const pair = key instanceof resolveSeq.Pair ? key : new resolveSeq.Pair(key);
-    const prev = resolveSeq.findPair(this.items, pair.key);
+    const pair = key instanceof stringifyNumber.Pair ? key : new stringifyNumber.Pair(key);
+    const prev = stringifyNumber.findPair(this.items, pair.key);
     if (!prev) this.items.push(pair);
   }
 
   get(key, keepPair) {
-    const pair = resolveSeq.findPair(this.items, key);
-    return !keepPair && pair instanceof resolveSeq.Pair ? pair.key instanceof resolveSeq.Scalar ? pair.key.value : pair.key : pair;
+    const pair = stringifyNumber.findPair(this.items, key);
+    return !keepPair && pair instanceof stringifyNumber.Pair ? pair.key instanceof stringifyNumber.Scalar ? pair.key.value : pair.key : pair;
   }
 
   set(key, value) {
     if (typeof value !== 'boolean') throw new Error(`Expected boolean value for set(key, value) in a YAML set, not ${typeof value}`);
-    const prev = resolveSeq.findPair(this.items, key);
+    const prev = stringifyNumber.findPair(this.items, key);
 
     if (prev && !value) {
       this.items.splice(this.items.indexOf(prev), 1);
     } else if (!prev && value) {
-      this.items.push(new resolveSeq.Pair(key));
+      this.items.push(new stringifyNumber.Pair(key));
     }
   }
 
@@ -470,18 +562,26 @@ class YAMLSet extends resolveSeq.YAMLMap {
 
 }
 
-PlainValue._defineProperty(YAMLSet, "tag", 'tag:yaml.org,2002:set');
+_rollupPluginBabelHelpers._defineProperty(YAMLSet, "tag", 'tag:yaml.org,2002:set');
 
-function parseSet(doc, cst) {
-  const map = resolveSeq.resolveMap(doc, cst);
-  if (!map.hasAllNullValues()) throw new PlainValue.YAMLSemanticError(cst, 'Set items must all have null values');
-  return Object.assign(new YAMLSet(), map);
+function parseSet(map, onError) {
+  if (map instanceof stringifyNumber.YAMLMap) {
+    if (map.hasAllNullValues()) return Object.assign(new YAMLSet(), map);else onError('Set items must all have null values');
+  } else onError('Expected a mapping for this tag');
+
+  return map;
 }
 
 function createSet(schema, iterable, ctx) {
-  const set = new YAMLSet();
+  const {
+    replacer
+  } = ctx;
+  const set = new YAMLSet(schema);
 
-  for (const value of iterable) set.items.push(resolveSeq.createPair(value, null, ctx));
+  for (let value of iterable) {
+    if (typeof replacer === 'function') value = replacer.call(iterable, value, value);
+    set.items.push(stringifyNumber.createPair(value, null, ctx));
+  }
 
   return set;
 }
@@ -495,33 +595,44 @@ const set = {
   createNode: createSet
 };
 
-const parseSexagesimal = (sign, parts) => {
-  const n = parts.split(':').reduce((n, p) => n * 60 + Number(p), 0);
-  return sign === '-' ? -n : n;
+/* global BigInt */
+
+const parseSexagesimal = (str, isInt) => {
+  const sign = str[0];
+  const parts = sign === '-' || sign === '+' ? str.substring(1) : str;
+
+  const num = n => isInt && stringifyNumber.intOptions.asBigInt ? BigInt(n) : Number(n);
+
+  const res = parts.replace(/_/g, '').split(':').reduce((res, p) => res * num(60) + num(p), num(0));
+  return sign === '-' ? num(-1) * res : res;
 }; // hhhh:mm:ss.sss
 
 
 const stringifySexagesimal = ({
   value
 }) => {
-  if (isNaN(value) || !isFinite(value)) return resolveSeq.stringifyNumber(value);
+  let num = n => n;
+
+  if (typeof value === 'bigint') num = n => BigInt(n);else if (isNaN(value) || !isFinite(value)) return stringifyNumber.stringifyNumber(value);
   let sign = '';
 
   if (value < 0) {
     sign = '-';
-    value = Math.abs(value);
+    value *= num(-1);
   }
 
-  const parts = [value % 60]; // seconds, including ms
+  const _60 = num(60);
+
+  const parts = [value % _60]; // seconds, including ms
 
   if (value < 60) {
     parts.unshift(0); // at least one : is required
   } else {
-    value = Math.round((value - parts[0]) / 60);
-    parts.unshift(value % 60); // minutes
+    value = (value - parts[0]) / _60;
+    parts.unshift(value % _60); // minutes
 
     if (value >= 60) {
-      value = Math.round((value - parts[0]) / 60);
+      value = (value - parts[0]) / _60;
       parts.unshift(value); // hours
     }
   }
@@ -531,12 +642,12 @@ const stringifySexagesimal = ({
 };
 
 const intTime = {
-  identify: value => typeof value === 'number',
+  identify: value => typeof value === 'bigint' || Number.isInteger(value),
   default: true,
   tag: 'tag:yaml.org,2002:int',
   format: 'TIME',
-  test: /^([-+]?)([0-9][0-9_]*(?::[0-5]?[0-9])+)$/,
-  resolve: (str, sign, parts) => parseSexagesimal(sign, parts.replace(/_/g, '')),
+  test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+$/,
+  resolve: str => parseSexagesimal(str, true),
   stringify: stringifySexagesimal
 };
 const floatTime = {
@@ -544,8 +655,8 @@ const floatTime = {
   default: true,
   tag: 'tag:yaml.org,2002:float',
   format: 'TIME',
-  test: /^([-+]?)([0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*)$/,
-  resolve: (str, sign, parts) => parseSexagesimal(sign, parts.replace(/_/g, '')),
+  test: /^[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*$/,
+  resolve: str => parseSexagesimal(str, false),
   stringify: stringifySexagesimal
 };
 const timestamp = {
@@ -555,23 +666,27 @@ const timestamp = {
   // If the time zone is omitted, the timestamp is assumed to be specified in UTC. The time part
   // may be omitted altogether, resulting in a date format. In such a case, the time part is
   // assumed to be 00:00:00Z (start of day, UTC).
-  test: RegExp('^(?:' + '([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})' + // YYYY-Mm-Dd
-  '(?:(?:t|T|[ \\t]+)' + // t | T | whitespace
+  test: RegExp('^([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})' + // YYYY-Mm-Dd
+  '(?:' + // time is optional
+  '(?:t|T|[ \\t]+)' + // t | T | whitespace
   '([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\.[0-9]+)?)' + // Hh:Mm:Ss(.ss)?
   '(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?' + // Z | +5 | -03:30
-  ')?' + ')$'),
-  resolve: (str, year, month, day, hour, minute, second, millisec, tz) => {
+  ')?$'),
+
+  resolve(str) {
+    let [, year, month, day, hour, minute, second, millisec, tz] = str.match(timestamp.test);
     if (millisec) millisec = (millisec + '00').substr(1, 3);
     let date = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec || 0);
 
     if (tz && tz !== 'Z') {
-      let d = parseSexagesimal(tz[0], tz.slice(1));
+      let d = parseSexagesimal(tz, false);
       if (Math.abs(d) < 30) d *= 60;
       date -= 60000 * d;
     }
 
     return new Date(date);
   },
+
   stringify: ({
     value
   }) => value.toISOString().replace(/((T00:00)?:00)?\.000Z$/, '')
@@ -581,14 +696,16 @@ const timestamp = {
 
 const boolStringify = ({
   value
-}) => value ? resolveSeq.boolOptions.trueStr : resolveSeq.boolOptions.falseStr;
+}) => value ? stringifyNumber.boolOptions.trueStr : stringifyNumber.boolOptions.falseStr;
 
 const intIdentify$2 = value => typeof value === 'bigint' || Number.isInteger(value);
 
-function intResolve$1(sign, src, radix) {
-  let str = src.replace(/_/g, '');
+function intResolve$1(str, offset, radix) {
+  const sign = str[0];
+  if (sign === '-' || sign === '+') offset += 1;
+  str = str.substring(offset).replace(/_/g, '');
 
-  if (resolveSeq.intOptions.asBigInt) {
+  if (stringifyNumber.intOptions.asBigInt) {
     switch (radix) {
       case 2:
         str = `0b${str}`;
@@ -621,78 +738,84 @@ function intStringify$1(node, radix, prefix) {
     return value < 0 ? '-' + prefix + str.substr(1) : prefix + str;
   }
 
-  return resolveSeq.stringifyNumber(node);
+  return stringifyNumber.stringifyNumber(node);
 }
 
 const yaml11 = failsafe.concat([{
   identify: value => value == null,
-  createNode: (schema, value, ctx) => ctx.wrapScalars ? new resolveSeq.Scalar(null) : null,
+  createNode: (schema, value, ctx) => ctx.wrapScalars ? new stringifyNumber.Scalar(null) : null,
   default: true,
   tag: 'tag:yaml.org,2002:null',
   test: /^(?:~|[Nn]ull|NULL)?$/,
-  resolve: () => null,
-  options: resolveSeq.nullOptions,
-  stringify: () => resolveSeq.nullOptions.nullStr
+  resolve: str => {
+    const node = new stringifyNumber.Scalar(null);
+    node.sourceStr = str;
+    return node;
+  },
+  options: stringifyNumber.nullOptions,
+  stringify: ({
+    sourceStr
+  }) => sourceStr !== null && sourceStr !== void 0 ? sourceStr : stringifyNumber.nullOptions.nullStr
 }, {
   identify: value => typeof value === 'boolean',
   default: true,
   tag: 'tag:yaml.org,2002:bool',
   test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/,
   resolve: () => true,
-  options: resolveSeq.boolOptions,
+  options: stringifyNumber.boolOptions,
   stringify: boolStringify
 }, {
   identify: value => typeof value === 'boolean',
   default: true,
   tag: 'tag:yaml.org,2002:bool',
-  test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/i,
+  test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/,
   resolve: () => false,
-  options: resolveSeq.boolOptions,
+  options: stringifyNumber.boolOptions,
   stringify: boolStringify
 }, {
   identify: intIdentify$2,
   default: true,
   tag: 'tag:yaml.org,2002:int',
   format: 'BIN',
-  test: /^([-+]?)0b([0-1_]+)$/,
-  resolve: (str, sign, bin) => intResolve$1(sign, bin, 2),
+  test: /^[-+]?0b[0-1_]+$/,
+  resolve: str => intResolve$1(str, 2, 2),
   stringify: node => intStringify$1(node, 2, '0b')
 }, {
   identify: intIdentify$2,
   default: true,
   tag: 'tag:yaml.org,2002:int',
   format: 'OCT',
-  test: /^([-+]?)0([0-7_]+)$/,
-  resolve: (str, sign, oct) => intResolve$1(sign, oct, 8),
+  test: /^[-+]?0[0-7_]+$/,
+  resolve: str => intResolve$1(str, 1, 8),
   stringify: node => intStringify$1(node, 8, '0')
 }, {
   identify: intIdentify$2,
   default: true,
   tag: 'tag:yaml.org,2002:int',
-  test: /^([-+]?)([0-9][0-9_]*)$/,
-  resolve: (str, sign, abs) => intResolve$1(sign, abs, 10),
-  stringify: resolveSeq.stringifyNumber
+  test: /^[-+]?[0-9][0-9_]*$/,
+  resolve: str => intResolve$1(str, 0, 10),
+  stringify: stringifyNumber.stringifyNumber
 }, {
   identify: intIdentify$2,
   default: true,
   tag: 'tag:yaml.org,2002:int',
   format: 'HEX',
-  test: /^([-+]?)0x([0-9a-fA-F_]+)$/,
-  resolve: (str, sign, hex) => intResolve$1(sign, hex, 16),
+  test: /^[-+]?0x[0-9a-fA-F_]+$/,
+  resolve: str => intResolve$1(str, 2, 16),
   stringify: node => intStringify$1(node, 16, '0x')
 }, {
   identify: value => typeof value === 'number',
   default: true,
   tag: 'tag:yaml.org,2002:float',
-  test: /^(?:[-+]?\.inf|(\.nan))$/i,
-  resolve: (str, nan) => nan ? NaN : str[0] === '-' ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY,
-  stringify: resolveSeq.stringifyNumber
+  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
 }, {
   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]+$/,
+  test: /^[-+]?(?:[0-9][0-9_]*)?(?:\.[0-9_]*)?[eE][-+]?[0-9]+$/,
   resolve: str => parseFloat(str.replace(/_/g, '')),
   stringify: ({
     value
@@ -701,20 +824,21 @@ const yaml11 = failsafe.concat([{
   identify: value => typeof value === 'number',
   default: true,
   tag: 'tag:yaml.org,2002:float',
-  test: /^[-+]?(?:[0-9][0-9_]*)?\.([0-9_]*)$/,
+  test: /^[-+]?(?:[0-9][0-9_]*)?\.[0-9_]*$/,
 
-  resolve(str, frac) {
-    const node = new resolveSeq.Scalar(parseFloat(str.replace(/_/g, '')));
+  resolve(str) {
+    const node = new stringifyNumber.Scalar(parseFloat(str.replace(/_/g, '')));
+    const dot = str.indexOf('.');
 
-    if (frac) {
-      const f = frac.replace(/_/g, '');
+    if (dot !== -1) {
+      const f = str.substring(dot + 1).replace(/_/g, '');
       if (f[f.length - 1] === '0') node.minFractionDigits = f.length;
     }
 
     return node;
   },
 
-  stringify: resolveSeq.stringifyNumber
+  stringify: stringifyNumber.stringifyNumber
 }], binary, omap, pairs, set, intTime, floatTime, timestamp);
 
 const schemas = {
@@ -805,4 +929,6 @@ class Schema {
 
 }
 
+exports.MERGE_KEY = MERGE_KEY;
+exports.Merge = Merge;
 exports.Schema = Schema;