yaml 2.0.0-2 → 2.0.0-6

package/browser/dist/resolve/resolveTag.js

@@ -1,107 +0,0 @@
-import { Collection } from '../ast/Collection.js';
-import { Scalar } from '../ast/Scalar.js';
-import { Type, defaultTags } from '../constants.js';
-import { YAMLSemanticError, YAMLWarning, YAMLReferenceError } from '../errors.js';
-import { resolveMap } from './resolveMap.js';
-import { resolveScalar } from './resolveScalar.js';
-import { resolveSeq } from './resolveSeq.js';
-
-function resolveByTagName({
-  knownTags,
-  tags
-}, tagName, value, onError) {
-  const matchWithTest = [];
-
-  for (const tag of tags) {
-    if (tag.tag === tagName) {
-      if (tag.test) {
-        if (typeof value === 'string') matchWithTest.push(tag);else onError("The tag ".concat(tagName, " cannot be applied to a collection"));
-      } else {
-        const res = tag.resolve(value, onError);
-        return res instanceof Collection ? res : new Scalar(res);
-      }
-    }
-  }
-
-  if (matchWithTest.length > 0) return resolveScalar(value, matchWithTest);
-  const kt = knownTags[tagName];
-
-  if (kt) {
-    tags.push(Object.assign({}, kt, {
-      default: false,
-      test: undefined
-    }));
-    const res = kt.resolve(value, onError);
-    return res instanceof Collection ? res : new Scalar(res);
-  }
-
-  return null;
-}
-
-function resolveTag(doc, node, tagName) {
-  const {
-    MAP,
-    SEQ,
-    STR
-  } = defaultTags;
-  let value, fallback;
-
-  const onError = message => doc.errors.push(new YAMLSemanticError(node, message));
-
-  try {
-    switch (node.type) {
-      case Type.FLOW_MAP:
-      case Type.MAP:
-        value = resolveMap(doc, node);
-        fallback = MAP;
-        if (tagName === SEQ || tagName === STR) onError("The tag ".concat(tagName, " cannot be applied to a mapping"));
-        break;
-
-      case Type.FLOW_SEQ:
-      case Type.SEQ:
-        value = resolveSeq(doc, node);
-        fallback = SEQ;
-        if (tagName === MAP || tagName === STR) onError("The tag ".concat(tagName, " cannot be applied to a sequence"));
-        break;
-
-      default:
-        value = node.strValue || '';
-
-        if (typeof value !== 'string') {
-          value.errors.forEach(error => doc.errors.push(error));
-          value = value.str;
-        }
-
-        if (tagName === MAP || tagName === SEQ) onError("The tag ".concat(tagName, " cannot be applied to a scalar"));
-        fallback = STR;
-    }
-
-    const res = resolveByTagName(doc.schema, tagName, value, onError);
-
-    if (res) {
-      if (tagName && node.tag) res.tag = tagName;
-      return res;
-    }
-  } catch (error) {
-    /* istanbul ignore if */
-    if (!error.source) error.source = node;
-    doc.errors.push(error);
-    return null;
-  }
-
-  try {
-    if (!fallback) throw new Error("The tag ".concat(tagName, " is unavailable"));
-    const msg = "The tag ".concat(tagName, " is unavailable, falling back to ").concat(fallback);
-    doc.warnings.push(new YAMLWarning(node, msg));
-    const res = resolveByTagName(doc.schema, fallback, value, onError);
-    res.tag = tagName;
-    return res;
-  } catch (error) {
-    const refError = new YAMLReferenceError(node, error.message);
-    refError.stack = error.stack;
-    doc.errors.push(refError);
-    return null;
-  }
-}
-
-export { resolveTag };

package/browser/dist/resolve/resolveTagName.js

@@ -1,87 +0,0 @@
-import { Type, defaultTags } from '../constants.js';
-import { YAMLSemanticError, YAMLWarning } from '../errors.js';
-
-function resolveTagHandle(doc, node) {
-  const {
-    handle,
-    suffix
-  } = node.tag;
-  let prefix = doc.tagPrefixes.find(p => p.handle === handle);
-
-  if (!prefix) {
-    const dtp = doc.getDefaults().tagPrefixes;
-    if (dtp) prefix = dtp.find(p => p.handle === handle);
-    if (!prefix) throw new YAMLSemanticError(node, "The ".concat(handle, " tag handle is non-default and was not declared."));
-  }
-
-  if (!suffix) throw new YAMLSemanticError(node, "The ".concat(handle, " tag has no suffix."));
-
-  if (handle === '!' && (doc.version || doc.options.version) === '1.0') {
-    if (suffix[0] === '^') {
-      doc.warnings.push(new YAMLWarning(node, 'YAML 1.0 ^ tag expansion is not supported'));
-      return suffix;
-    }
-
-    if (/[:/]/.test(suffix)) {
-      // word/foo -> tag:word.yaml.org,2002:foo
-      const vocab = suffix.match(/^([a-z0-9-]+)\/(.*)/i);
-      return vocab ? "tag:".concat(vocab[1], ".yaml.org,2002:").concat(vocab[2]) : "tag:".concat(suffix);
-    }
-  }
-
-  return prefix.prefix + decodeURIComponent(suffix);
-}
-
-function resolveTagName(doc, node) {
-  const {
-    tag,
-    type
-  } = node;
-  let nonSpecific = false;
-
-  if (tag) {
-    const {
-      handle,
-      suffix,
-      verbatim
-    } = tag;
-
-    if (verbatim) {
-      if (verbatim !== '!' && verbatim !== '!!') return verbatim;
-      const msg = "Verbatim tags aren't resolved, so ".concat(verbatim, " is invalid.");
-      doc.errors.push(new YAMLSemanticError(node, msg));
-    } else if (handle === '!' && !suffix) {
-      nonSpecific = true;
-    } else {
-      try {
-        return resolveTagHandle(doc, node);
-      } catch (error) {
-        doc.errors.push(error);
-      }
-    }
-  }
-
-  switch (type) {
-    case Type.BLOCK_FOLDED:
-    case Type.BLOCK_LITERAL:
-    case Type.QUOTE_DOUBLE:
-    case Type.QUOTE_SINGLE:
-      return defaultTags.STR;
-
-    case Type.FLOW_MAP:
-    case Type.MAP:
-      return defaultTags.MAP;
-
-    case Type.FLOW_SEQ:
-    case Type.SEQ:
-      return defaultTags.SEQ;
-
-    case Type.PLAIN:
-      return nonSpecific ? defaultTags.STR : null;
-
-    default:
-      return null;
-  }
-}
-
-export { resolveTagName };

package/browser/dist/stringify/addComment.js

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

package/browser/dist/stringify/stringifyTag.js

@@ -1,28 +0,0 @@
-function stringifyTag(doc, tag) {
-  if ((doc.version || doc.options.version) === '1.0') {
-    const priv = tag.match(/^tag:private\.yaml\.org,2002:([^:/]+)$/);
-    if (priv) return '!' + priv[1];
-    const vocab = tag.match(/^tag:([a-zA-Z0-9-]+)\.yaml\.org,2002:(.*)/);
-    return vocab ? "!".concat(vocab[1], "/").concat(vocab[2]) : "!".concat(tag.replace(/^tag:/, ''));
-  }
-
-  let p = doc.tagPrefixes.find(p => tag.indexOf(p.prefix) === 0);
-
-  if (!p) {
-    const dtp = doc.getDefaults().tagPrefixes;
-    p = dtp && dtp.find(p => tag.indexOf(p.prefix) === 0);
-  }
-
-  if (!p) return tag[0] === '!' ? tag : "!<".concat(tag, ">");
-  const suffix = tag.substr(p.prefix.length).replace(/[!,[\]{}]/g, ch => ({
-    '!': '%21',
-    ',': '%2C',
-    '[': '%5B',
-    ']': '%5D',
-    '{': '%7B',
-    '}': '%7D'
-  })[ch]);
-  return p.handle + suffix;
-}
-
-export { stringifyTag };

package/browser/dist/tags/core.js

@@ -1,128 +0,0 @@
-import { Scalar } from '../ast/Scalar.js';
-import { stringifyNumber } from '../stringify/stringifyNumber.js';
-import { failsafe } from './failsafe/index.js';
-import { nullOptions, boolOptions, intOptions } from './options.js';
-
-/* global BigInt */
-
-const intIdentify = value => typeof value === 'bigint' || Number.isInteger(value);
-
-const intResolve = (src, offset, radix) => 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 stringifyNumber(node);
-}
-
-function stringifyBool(node) {
-  const {
-    value,
-    sourceStr
-  } = node;
-
-  if (sourceStr) {
-    const match = boolObj.test.test(sourceStr);
-    if (match && value === (sourceStr[0] === 't' || sourceStr[0] === 'T')) return sourceStr;
-  }
-
-  return value ? boolOptions.trueStr : boolOptions.falseStr;
-}
-
-const nullObj = {
-  identify: value => value == null,
-  createNode: (schema, value, ctx) => ctx.wrapScalars ? new Scalar(null) : null,
-  default: true,
-  tag: 'tag:yaml.org,2002:null',
-  test: /^(?:~|[Nn]ull|NULL)?$/,
-  resolve: str => {
-    const node = new Scalar(null);
-    node.sourceStr = str;
-    return node;
-  },
-  options: nullOptions,
-  stringify: ({
-    sourceStr
-  }) => sourceStr !== null && sourceStr !== void 0 ? sourceStr : nullOptions.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 => {
-    const node = new Scalar(str[0] === 't' || str[0] === 'T');
-    node.sourceStr = str;
-    return node;
-  },
-  options: boolOptions,
-  stringify: stringifyBool
-};
-const octObj = {
-  identify: value => intIdentify(value) && value >= 0,
-  default: true,
-  tag: 'tag:yaml.org,2002:int',
-  format: 'OCT',
-  test: /^0o[0-7]+$/,
-  resolve: str => intResolve(str, 2, 8),
-  options: intOptions,
-  stringify: node => intStringify(node, 8, '0o')
-};
-const intObj = {
-  identify: intIdentify,
-  default: true,
-  tag: 'tag:yaml.org,2002:int',
-  test: /^[-+]?[0-9]+$/,
-  resolve: str => intResolve(str, 0, 10),
-  options: intOptions,
-  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 => intResolve(str, 2, 16),
-  options: intOptions,
-  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 };

package/browser/dist/tags/failsafe/index.js

@@ -1,7 +0,0 @@
-import { map } from './map.js';
-import { seq } from './seq.js';
-import { string } from './string.js';
-
-const failsafe = [map, seq, string];
-
-export { failsafe };

package/browser/dist/tags/failsafe/map.js

@@ -1,37 +0,0 @@
-import { createPair } from '../../ast/Pair.js';
-import { YAMLMap } from '../../ast/YAMLMap.js';
-
-function createMap(schema, obj, ctx) {
-  const {
-    keepUndefined,
-    replacer
-  } = ctx;
-  const map = new YAMLMap(schema);
-
-  const add = (key, value) => {
-    if (typeof replacer === 'function') value = replacer.call(obj, key, value);else if (Array.isArray(replacer) && !replacer.includes(key)) return;
-    if (value !== undefined || keepUndefined) map.items.push(createPair(key, value, ctx));
-  };
-
-  if (obj instanceof Map) {
-    for (const [key, value] of obj) add(key, value);
-  } else if (obj && typeof obj === 'object') {
-    for (const key of Object.keys(obj)) add(key, obj[key]);
-  }
-
-  if (typeof schema.sortMapEntries === 'function') {
-    map.items.sort(schema.sortMapEntries);
-  }
-
-  return map;
-}
-
-const map = {
-  createNode: createMap,
-  default: true,
-  nodeClass: YAMLMap,
-  tag: 'tag:yaml.org,2002:map',
-  resolve: map => map
-};
-
-export { map };

package/browser/dist/tags/failsafe/seq.js

@@ -1,34 +0,0 @@
-import { YAMLSeq } from '../../ast/YAMLSeq.js';
-import { createNode } from '../../doc/createNode.js';
-
-function createSeq(schema, obj, ctx) {
-  const {
-    replacer
-  } = ctx;
-  const seq = new YAMLSeq(schema);
-
-  if (obj && obj[Symbol.iterator]) {
-    let i = 0;
-
-    for (let it of obj) {
-      if (typeof replacer === 'function') {
-        const key = obj instanceof Set ? it : String(i++);
-        it = replacer.call(obj, key, it);
-      }
-
-      seq.items.push(createNode(it, null, ctx));
-    }
-  }
-
-  return seq;
-}
-
-const seq = {
-  createNode: createSeq,
-  default: true,
-  nodeClass: YAMLSeq,
-  tag: 'tag:yaml.org,2002:seq',
-  resolve: seq => seq
-};
-
-export { seq };

package/browser/dist/tags/failsafe/string.js

@@ -1,20 +0,0 @@
-import { stringifyString } from '../../stringify/stringifyString.js';
-import { strOptions } from '../options.js';
-
-const string = {
-  identify: value => typeof value === 'string',
-  default: true,
-  tag: 'tag:yaml.org,2002:str',
-  resolve: str => str,
-
-  stringify(item, ctx, onComment, onChompKeep) {
-    ctx = Object.assign({
-      actualString: true
-    }, ctx);
-    return stringifyString(item, ctx, onComment, onChompKeep);
-  },
-
-  options: strOptions
-};
-
-export { string };

package/browser/dist/tags/index.js

@@ -1,39 +0,0 @@
-import { boolObj, floatObj, expObj, nanObj, intObj, hexObj, octObj, nullObj, core } from './core.js';
-import { failsafe } from './failsafe/index.js';
-import { json } from './json.js';
-import { yaml11 } from './yaml-1.1/index.js';
-import { map } from './failsafe/map.js';
-import { seq } from './failsafe/seq.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 { set } from './yaml-1.1/set.js';
-import { floatTime, intTime, timestamp } from './yaml-1.1/timestamp.js';
-
-const schemas = {
-  core,
-  failsafe,
-  json,
-  yaml11
-};
-const tags = {
-  binary,
-  bool: boolObj,
-  float: floatObj,
-  floatExp: expObj,
-  floatNaN: nanObj,
-  floatTime,
-  int: intObj,
-  intHex: hexObj,
-  intOct: octObj,
-  intTime,
-  map,
-  null: nullObj,
-  omap,
-  pairs,
-  seq,
-  set,
-  timestamp
-};
-
-export { schemas, tags };

package/browser/dist/tags/json.js

@@ -1,62 +0,0 @@
-import { Scalar } from '../ast/Scalar.js';
-import { map } from './failsafe/map.js';
-import { seq } from './failsafe/seq.js';
-import { intOptions } from './options.js';
-
-/* global BigInt */
-
-const intIdentify = value => typeof value === 'bigint' || Number.isInteger(value);
-
-const stringifyJSON = ({
-  value
-}) => JSON.stringify(value);
-
-const json = [map, seq, {
-  identify: value => typeof value === 'string',
-  default: true,
-  tag: 'tag:yaml.org,2002:str',
-  resolve: str => str,
-  stringify: stringifyJSON
-}, {
-  identify: value => value == null,
-  createNode: (schema, value, ctx) => ctx.wrapScalars ? new Scalar(null) : null,
-  default: true,
-  tag: 'tag:yaml.org,2002:null',
-  test: /^null$/,
-  resolve: () => null,
-  stringify: stringifyJSON
-}, {
-  identify: value => typeof value === 'boolean',
-  default: true,
-  tag: 'tag:yaml.org,2002:bool',
-  test: /^true|false$/,
-  resolve: str => str === 'true',
-  stringify: stringifyJSON
-}, {
-  identify: intIdentify,
-  default: true,
-  tag: 'tag:yaml.org,2002:int',
-  test: /^-?(?:0|[1-9][0-9]*)$/,
-  resolve: str => intOptions.asBigInt ? BigInt(str) : parseInt(str, 10),
-  stringify: ({
-    value
-  }) => intIdentify(value) ? value.toString() : JSON.stringify(value)
-}, {
-  identify: value => typeof value === 'number',
-  default: true,
-  tag: 'tag:yaml.org,2002:float',
-  test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,
-  resolve: str => parseFloat(str),
-  stringify: stringifyJSON
-}, {
-  default: true,
-  test: /^/,
-
-  resolve(str, onError) {
-    onError("Unresolved plain scalar ".concat(JSON.stringify(str)));
-    return str;
-  }
-
-}];
-
-export { json };

package/browser/dist/tags/options.js

@@ -1,31 +0,0 @@
-import { Type } from '../constants.js';
-
-const binaryOptions = {
-  defaultType: Type.BLOCK_LITERAL,
-  lineWidth: 76
-};
-const boolOptions = {
-  trueStr: 'true',
-  falseStr: 'false'
-};
-const intOptions = {
-  asBigInt: false
-};
-const nullOptions = {
-  nullStr: 'null'
-};
-const strOptions = {
-  defaultType: Type.PLAIN,
-  defaultKeyType: Type.PLAIN,
-  defaultQuoteSingle: false,
-  doubleQuoted: {
-    jsonEncoding: false,
-    minMultiLineLength: 40
-  },
-  fold: {
-    lineWidth: 80,
-    minContentWidth: 20
-  }
-};
-
-export { binaryOptions, boolOptions, intOptions, nullOptions, strOptions };

package/browser/dist/tags/yaml-1.1/binary.js

@@ -1,83 +0,0 @@
-import { Type } from '../../constants.js';
-import { stringifyString } from '../../stringify/stringifyString.js';
-import { binaryOptions } from '../options.js';
-
-/* global atob, btoa, Buffer */
-const binary = {
-  identify: value => value instanceof Uint8Array,
-  // Buffer inherits from Uint8Array
-  default: false,
-  tag: 'tag:yaml.org,2002:binary',
-
-  /**
-   * Returns a Buffer in node and an Uint8Array in browsers
-   *
-   * To use the resulting buffer as an image, you'll want to do something like:
-   *
-   *   const blob = new Blob([buffer], { type: 'image/jpeg' })
-   *   document.querySelector('#photo').src = URL.createObjectURL(blob)
-   */
-  resolve(src, onError) {
-    if (typeof Buffer === 'function') {
-      return Buffer.from(src, 'base64');
-    } else if (typeof atob === 'function') {
-      // On IE 11, atob() can't handle newlines
-      const str = atob(src.replace(/[\n\r]/g, ''));
-      const buffer = new Uint8Array(str.length);
-
-      for (let i = 0; i < str.length; ++i) buffer[i] = str.charCodeAt(i);
-
-      return buffer;
-    } else {
-      onError('This environment does not support reading binary tags; either Buffer or atob is required');
-      return src;
-    }
-  },
-
-  options: binaryOptions,
-  stringify: ({
-    comment,
-    type,
-    value
-  }, ctx, onComment, onChompKeep) => {
-    let src;
-
-    if (typeof Buffer === 'function') {
-      src = value instanceof Buffer ? value.toString('base64') : Buffer.from(value.buffer).toString('base64');
-    } else if (typeof btoa === 'function') {
-      let s = '';
-
-      for (let i = 0; i < value.length; ++i) s += String.fromCharCode(value[i]);
-
-      src = btoa(s);
-    } else {
-      throw new Error('This environment does not support writing binary tags; either Buffer or btoa is required');
-    }
-
-    if (!type) type = binaryOptions.defaultType;
-
-    if (type === Type.QUOTE_DOUBLE) {
-      value = src;
-    } else {
-      const {
-        lineWidth
-      } = binaryOptions;
-      const n = Math.ceil(src.length / lineWidth);
-      const lines = new Array(n);
-
-      for (let i = 0, o = 0; i < n; ++i, o += lineWidth) {
-        lines[i] = src.substr(o, lineWidth);
-      }
-
-      value = lines.join(type === Type.BLOCK_LITERAL ? '\n' : ' ');
-    }
-
-    return stringifyString({
-      comment,
-      type,
-      value
-    }, ctx, onComment, onChompKeep);
-  }
-};
-
-export { binary };