yaml 1.9.1 → 1.10.2

package/dist/schema/index.js

@@ -1,310 +0,0 @@
-"use strict";
-
-exports.Schema = void 0;
-
-var _warnings = require("../warnings");
-
-var _constants = require("../constants");
-
-var _errors = require("../errors");
-
-var _stringify = require("../stringify");
-
-var _tags = require("../tags");
-
-var _string = require("../tags/failsafe/string");
-
-var _Alias = require("./Alias");
-
-var _Collection = require("./Collection");
-
-var _Node = require("./Node");
-
-var _Pair = require("./Pair");
-
-var _Scalar = require("./Scalar");
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-const isMap = ({
-  type
-}) => type === _constants.Type.FLOW_MAP || type === _constants.Type.MAP;
-
-const isSeq = ({
-  type
-}) => type === _constants.Type.FLOW_SEQ || type === _constants.Type.SEQ;
-
-class Schema {
-  constructor({
-    customTags,
-    merge,
-    schema,
-    sortMapEntries,
-    tags: deprecatedCustomTags
-  }) {
-    this.merge = !!merge;
-    this.name = schema;
-    this.sortMapEntries = sortMapEntries === true ? (a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0 : sortMapEntries || null;
-    this.tags = _tags.schemas[schema.replace(/\W/g, '')]; // 'yaml-1.1' -> 'yaml11'
-
-    if (!this.tags) {
-      const keys = Object.keys(_tags.schemas).map(key => JSON.stringify(key)).join(', ');
-      throw new Error(`Unknown schema "${schema}"; use one of ${keys}`);
-    }
-
-    if (!customTags && deprecatedCustomTags) {
-      customTags = deprecatedCustomTags;
-      (0, _warnings.warnOptionDeprecation)('tags', 'customTags');
-    }
-
-    if (Array.isArray(customTags)) {
-      for (const tag of customTags) this.tags = this.tags.concat(tag);
-    } else if (typeof customTags === 'function') {
-      this.tags = customTags(this.tags.slice());
-    }
-
-    for (let i = 0; i < this.tags.length; ++i) {
-      const tag = this.tags[i];
-
-      if (typeof tag === 'string') {
-        const tagObj = _tags.tags[tag];
-
-        if (!tagObj) {
-          const keys = Object.keys(_tags.tags).map(key => JSON.stringify(key)).join(', ');
-          throw new Error(`Unknown custom tag "${tag}"; use one of ${keys}`);
-        }
-
-        this.tags[i] = tagObj;
-      }
-    }
-  }
-
-  createNode(value, wrapScalars, tag, ctx) {
-    if (value instanceof _Node.Node) return value;
-    let tagObj;
-
-    if (tag) {
-      if (tag.startsWith('!!')) tag = Schema.defaultPrefix + tag.slice(2);
-      const match = this.tags.filter(t => t.tag === tag);
-      tagObj = match.find(t => !t.format) || match[0];
-      if (!tagObj) throw new Error(`Tag ${tag} not found`);
-    } else {
-      // TODO: deprecate/remove class check
-      tagObj = this.tags.find(t => (t.identify && t.identify(value) || t.class && value instanceof t.class) && !t.format);
-
-      if (!tagObj) {
-        if (typeof value.toJSON === 'function') value = value.toJSON();
-        if (typeof value !== 'object') return wrapScalars ? new _Scalar.Scalar(value) : value;
-        tagObj = value instanceof Map ? _tags.tags.map : value[Symbol.iterator] ? _tags.tags.seq : _tags.tags.map;
-      }
-    }
-
-    if (!ctx) ctx = {
-      wrapScalars
-    };else ctx.wrapScalars = wrapScalars;
-
-    if (ctx.onTagObj) {
-      ctx.onTagObj(tagObj);
-      delete ctx.onTagObj;
-    }
-
-    const obj = {};
-
-    if (value && typeof value === 'object' && ctx.prevObjects) {
-      const prev = ctx.prevObjects.get(value);
-
-      if (prev) {
-        const alias = new _Alias.Alias(prev); // leaves source dirty; must be cleaned by caller
-
-        ctx.aliasNodes.push(alias);
-        return alias;
-      }
-
-      obj.value = value;
-      ctx.prevObjects.set(value, obj);
-    }
-
-    obj.node = tagObj.createNode ? tagObj.createNode(this, value, ctx) : wrapScalars ? new _Scalar.Scalar(value) : value;
-    if (tag && obj.node instanceof _Node.Node) obj.node.tag = tag;
-    return obj.node;
-  }
-
-  createPair(key, value, ctx) {
-    const k = this.createNode(key, ctx.wrapScalars, null, ctx);
-    const v = this.createNode(value, ctx.wrapScalars, null, ctx);
-    return new _Pair.Pair(k, v);
-  } // falls back to string on no match
-
-
-  resolveScalar(str, tags) {
-    if (!tags) tags = this.tags;
-
-    for (let i = 0; i < tags.length; ++i) {
-      const {
-        format,
-        test,
-        resolve
-      } = tags[i];
-
-      if (test) {
-        const match = str.match(test);
-
-        if (match) {
-          let res = resolve.apply(null, match);
-          if (!(res instanceof _Scalar.Scalar)) res = new _Scalar.Scalar(res);
-          if (format) res.format = format;
-          return res;
-        }
-      }
-    }
-
-    if (this.tags.scalarFallback) str = this.tags.scalarFallback(str);
-    return new _Scalar.Scalar(str);
-  } // sets node.resolved on success
-
-
-  resolveNode(doc, node, tagName) {
-    const tags = this.tags.filter(({
-      tag
-    }) => tag === tagName);
-    const generic = tags.find(({
-      test
-    }) => !test);
-    if (node.error) doc.errors.push(node.error);
-
-    try {
-      if (generic) {
-        let res = generic.resolve(doc, node);
-        if (!(res instanceof _Collection.Collection)) res = new _Scalar.Scalar(res);
-        node.resolved = res;
-      } else {
-        const str = (0, _string.resolveString)(doc, node);
-
-        if (typeof str === 'string' && tags.length > 0) {
-          node.resolved = this.resolveScalar(str, tags);
-        }
-      }
-    } catch (error) {
-      /* istanbul ignore if */
-      if (!error.source) error.source = node;
-      doc.errors.push(error);
-      node.resolved = null;
-    }
-
-    if (!node.resolved) return null;
-    if (tagName && node.tag) node.resolved.tag = tagName;
-    return node.resolved;
-  }
-
-  resolveNodeWithFallback(doc, node, tagName) {
-    const res = this.resolveNode(doc, node, tagName);
-    if (Object.prototype.hasOwnProperty.call(node, 'resolved')) return res;
-    const fallback = isMap(node) ? Schema.defaultTags.MAP : isSeq(node) ? Schema.defaultTags.SEQ : Schema.defaultTags.STR;
-    /* istanbul ignore else */
-
-    if (fallback) {
-      doc.warnings.push(new _errors.YAMLWarning(node, `The tag ${tagName} is unavailable, falling back to ${fallback}`));
-      const res = this.resolveNode(doc, node, fallback);
-      res.tag = tagName;
-      return res;
-    } else {
-      doc.errors.push(new _errors.YAMLReferenceError(node, `The tag ${tagName} is unavailable`));
-      return null;
-    }
-  }
-
-  getTagObject(item) {
-    if (item instanceof _Alias.Alias) return _Alias.Alias;
-
-    if (item.tag) {
-      const match = this.tags.filter(t => t.tag === item.tag);
-      if (match.length > 0) return match.find(t => t.format === item.format) || match[0];
-    }
-
-    let tagObj, obj;
-
-    if (item instanceof _Scalar.Scalar) {
-      obj = item.value; // TODO: deprecate/remove class check
-
-      const match = this.tags.filter(t => t.identify && t.identify(obj) || t.class && obj instanceof t.class);
-      tagObj = match.find(t => t.format === item.format) || match.find(t => !t.format);
-    } else {
-      obj = item;
-      tagObj = this.tags.find(t => t.nodeClass && obj instanceof t.nodeClass);
-    }
-
-    if (!tagObj) {
-      const name = obj && obj.constructor ? obj.constructor.name : typeof obj;
-      throw new Error(`Tag not resolved for ${name} value`);
-    }
-
-    return tagObj;
-  } // needs to be called before stringifier to allow for circular anchor refs
-
-
-  stringifyProps(node, tagObj, {
-    anchors,
-    doc
-  }) {
-    const props = [];
-    const anchor = doc.anchors.getName(node);
-
-    if (anchor) {
-      anchors[anchor] = node;
-      props.push(`&${anchor}`);
-    }
-
-    if (node.tag) {
-      props.push(doc.stringifyTag(node.tag));
-    } else if (!tagObj.default) {
-      props.push(doc.stringifyTag(tagObj.tag));
-    }
-
-    return props.join(' ');
-  }
-
-  stringify(item, ctx, onComment, onChompKeep) {
-    let tagObj;
-
-    if (!(item instanceof _Node.Node)) {
-      const createCtx = {
-        aliasNodes: [],
-        onTagObj: o => tagObj = o,
-        prevObjects: new Map()
-      };
-      item = this.createNode(item, true, null, createCtx);
-      const {
-        anchors
-      } = ctx.doc;
-
-      for (const alias of createCtx.aliasNodes) {
-        alias.source = alias.source.node;
-        let name = anchors.getName(alias.source);
-
-        if (!name) {
-          name = anchors.newName();
-          anchors.map[name] = alias.source;
-        }
-      }
-    }
-
-    ctx.tags = this;
-    if (item instanceof _Pair.Pair) return item.toString(ctx, onComment, onChompKeep);
-    if (!tagObj) tagObj = this.getTagObject(item);
-    const props = this.stringifyProps(item, tagObj, ctx);
-    if (props.length > 0) ctx.indentAtStart = (ctx.indentAtStart || 0) + props.length + 1;
-    const str = typeof tagObj.stringify === 'function' ? tagObj.stringify(item, ctx, onComment, onChompKeep) : item instanceof _Collection.Collection ? item.toString(ctx, onComment, onChompKeep) : (0, _stringify.stringifyString)(item, ctx, onComment, onChompKeep);
-    return props ? item instanceof _Collection.Collection && str[0] !== '{' && str[0] !== '[' ? `${props}\n${ctx.indent}${str}` : `${props} ${str}` : str;
-  }
-
-}
-
-exports.Schema = Schema;
-
-_defineProperty(Schema, "defaultPrefix", 'tag:yaml.org,2002:');
-
-_defineProperty(Schema, "defaultTags", {
-  MAP: 'tag:yaml.org,2002:map',
-  SEQ: 'tag:yaml.org,2002:seq',
-  STR: 'tag:yaml.org,2002:str'
-});

package/dist/schema/parseMap.js

@@ -1,334 +0,0 @@
-"use strict";
-
-exports.parseMap = parseMap;
-
-var _constants = require("../constants");
-
-var _PlainValue = require("../cst/PlainValue");
-
-var _errors = require("../errors");
-
-var _Map = require("./Map");
-
-var _Merge = require("./Merge");
-
-var _Pair = require("./Pair");
-
-var _parseUtils = require("./parseUtils");
-
-var _Alias = require("./Alias");
-
-var _Collection = require("./Collection");
-
-function parseMap(doc, cst) {
-  if (cst.type !== _constants.Type.MAP && cst.type !== _constants.Type.FLOW_MAP) {
-    const msg = `A ${cst.type} node cannot be resolved as a mapping`;
-    doc.errors.push(new _errors.YAMLSyntaxError(cst, msg));
-    return null;
-  }
-
-  const {
-    comments,
-    items
-  } = cst.type === _constants.Type.FLOW_MAP ? resolveFlowMapItems(doc, cst) : resolveBlockMapItems(doc, cst);
-  const map = new _Map.YAMLMap();
-  map.items = items;
-  (0, _parseUtils.resolveComments)(map, comments);
-  let hasCollectionKey = false;
-
-  for (let i = 0; i < items.length; ++i) {
-    const {
-      key: iKey
-    } = items[i];
-    if (iKey instanceof _Collection.Collection) hasCollectionKey = true;
-
-    if (doc.schema.merge && iKey && iKey.value === _Merge.MERGE_KEY) {
-      items[i] = new _Merge.Merge(items[i]);
-      const sources = items[i].value.items;
-      let error = null;
-      sources.some(node => {
-        if (node instanceof _Alias.Alias) {
-          // During parsing, alias sources are CST nodes; to account for
-          // circular references their resolved values can't be used here.
-          const {
-            type
-          } = node.source;
-          if (type === _constants.Type.MAP || type === _constants.Type.FLOW_MAP) return false;
-          return error = 'Merge nodes aliases can only point to maps';
-        }
-
-        return error = 'Merge nodes can only have Alias nodes as values';
-      });
-      if (error) doc.errors.push(new _errors.YAMLSemanticError(cst, error));
-    } else {
-      for (let j = i + 1; j < items.length; ++j) {
-        const {
-          key: jKey
-        } = items[j];
-
-        if (iKey === jKey || iKey && jKey && Object.prototype.hasOwnProperty.call(iKey, 'value') && iKey.value === jKey.value) {
-          const msg = `Map keys must be unique; "${iKey}" is repeated`;
-          doc.errors.push(new _errors.YAMLSemanticError(cst, msg));
-          break;
-        }
-      }
-    }
-  }
-
-  if (hasCollectionKey && !doc.options.mapAsMap) {
-    const warn = 'Keys with collection values will be stringified as YAML due to JS Object restrictions. Use mapAsMap: true to avoid this.';
-    doc.warnings.push(new _errors.YAMLWarning(cst, warn));
-  }
-
-  cst.resolved = map;
-  return map;
-}
-
-const valueHasPairComment = ({
-  context: {
-    lineStart,
-    node,
-    src
-  },
-  props
-}) => {
-  if (props.length === 0) return false;
-  const {
-    start
-  } = props[0];
-  if (node && start > node.valueRange.start) return false;
-  if (src[start] !== _constants.Char.COMMENT) return false;
-
-  for (let i = lineStart; i < start; ++i) if (src[i] === '\n') return false;
-
-  return true;
-};
-
-function resolvePairComment(item, pair) {
-  if (!valueHasPairComment(item)) return;
-  const comment = item.getPropValue(0, _constants.Char.COMMENT, true);
-  let found = false;
-  const cb = pair.value.commentBefore;
-
-  if (cb && cb.startsWith(comment)) {
-    pair.value.commentBefore = cb.substr(comment.length + 1);
-    found = true;
-  } else {
-    const cc = pair.value.comment;
-
-    if (!item.node && cc && cc.startsWith(comment)) {
-      pair.value.comment = cc.substr(comment.length + 1);
-      found = true;
-    }
-  }
-
-  if (found) pair.comment = comment;
-}
-
-function resolveBlockMapItems(doc, cst) {
-  const comments = [];
-  const items = [];
-  let key = undefined;
-  let keyStart = null;
-
-  for (let i = 0; i < cst.items.length; ++i) {
-    const item = cst.items[i];
-
-    switch (item.type) {
-      case _constants.Type.BLANK_LINE:
-        comments.push({
-          afterKey: !!key,
-          before: items.length
-        });
-        break;
-
-      case _constants.Type.COMMENT:
-        comments.push({
-          afterKey: !!key,
-          before: items.length,
-          comment: item.comment
-        });
-        break;
-
-      case _constants.Type.MAP_KEY:
-        if (key !== undefined) items.push(new _Pair.Pair(key));
-        if (item.error) doc.errors.push(item.error);
-        key = doc.resolveNode(item.node);
-        keyStart = null;
-        break;
-
-      case _constants.Type.MAP_VALUE:
-        {
-          if (key === undefined) key = null;
-          if (item.error) doc.errors.push(item.error);
-
-          if (!item.context.atLineStart && item.node && item.node.type === _constants.Type.MAP && !item.node.context.atLineStart) {
-            const msg = 'Nested mappings are not allowed in compact mappings';
-            doc.errors.push(new _errors.YAMLSemanticError(item.node, msg));
-          }
-
-          let valueNode = item.node;
-
-          if (!valueNode && item.props.length > 0) {
-            // Comments on an empty mapping value need to be preserved, so we
-            // need to construct a minimal empty node here to use instead of the
-            // missing `item.node`. -- eemeli/yaml#19
-            valueNode = new _PlainValue.PlainValue(_constants.Type.PLAIN, []);
-            valueNode.context = {
-              parent: item,
-              src: item.context.src
-            };
-            const pos = item.range.start + 1;
-            valueNode.range = {
-              start: pos,
-              end: pos
-            };
-            valueNode.valueRange = {
-              start: pos,
-              end: pos
-            };
-
-            if (typeof item.range.origStart === 'number') {
-              const origPos = item.range.origStart + 1;
-              valueNode.range.origStart = valueNode.range.origEnd = origPos;
-              valueNode.valueRange.origStart = valueNode.valueRange.origEnd = origPos;
-            }
-          }
-
-          const pair = new _Pair.Pair(key, doc.resolveNode(valueNode));
-          resolvePairComment(item, pair);
-          items.push(pair);
-          (0, _parseUtils.checkKeyLength)(doc.errors, cst, i, key, keyStart);
-          key = undefined;
-          keyStart = null;
-        }
-        break;
-
-      default:
-        if (key !== undefined) items.push(new _Pair.Pair(key));
-        key = doc.resolveNode(item);
-        keyStart = item.range.start;
-        if (item.error) doc.errors.push(item.error);
-
-        next: for (let j = i + 1;; ++j) {
-          const nextItem = cst.items[j];
-
-          switch (nextItem && nextItem.type) {
-            case _constants.Type.BLANK_LINE:
-            case _constants.Type.COMMENT:
-              continue next;
-
-            case _constants.Type.MAP_VALUE:
-              break next;
-
-            default:
-              doc.errors.push(new _errors.YAMLSemanticError(item, 'Implicit map keys need to be followed by map values'));
-              break next;
-          }
-        }
-
-        if (item.valueRangeContainsNewline) {
-          const msg = 'Implicit map keys need to be on a single line';
-          doc.errors.push(new _errors.YAMLSemanticError(item, msg));
-        }
-
-    }
-  }
-
-  if (key !== undefined) items.push(new _Pair.Pair(key));
-  return {
-    comments,
-    items
-  };
-}
-
-function resolveFlowMapItems(doc, cst) {
-  const comments = [];
-  const items = [];
-  let key = undefined;
-  let keyStart = null;
-  let explicitKey = false;
-  let next = '{';
-
-  for (let i = 0; i < cst.items.length; ++i) {
-    (0, _parseUtils.checkKeyLength)(doc.errors, cst, i, key, keyStart);
-    const item = cst.items[i];
-
-    if (typeof item.char === 'string') {
-      const {
-        char,
-        offset
-      } = item;
-
-      if (char === '?' && key === undefined && !explicitKey) {
-        explicitKey = true;
-        next = ':';
-        continue;
-      }
-
-      if (char === ':') {
-        if (key === undefined) key = null;
-
-        if (next === ':') {
-          next = ',';
-          continue;
-        }
-      } else {
-        if (explicitKey) {
-          if (key === undefined && char !== ',') key = null;
-          explicitKey = false;
-        }
-
-        if (key !== undefined) {
-          items.push(new _Pair.Pair(key));
-          key = undefined;
-          keyStart = null;
-
-          if (char === ',') {
-            next = ':';
-            continue;
-          }
-        }
-      }
-
-      if (char === '}') {
-        if (i === cst.items.length - 1) continue;
-      } else if (char === next) {
-        next = ':';
-        continue;
-      }
-
-      const msg = `Flow map contains an unexpected ${char}`;
-      const err = new _errors.YAMLSyntaxError(cst, msg);
-      err.offset = offset;
-      doc.errors.push(err);
-    } else if (item.type === _constants.Type.BLANK_LINE) {
-      comments.push({
-        afterKey: !!key,
-        before: items.length
-      });
-    } else if (item.type === _constants.Type.COMMENT) {
-      comments.push({
-        afterKey: !!key,
-        before: items.length,
-        comment: item.comment
-      });
-    } else if (key === undefined) {
-      if (next === ',') doc.errors.push(new _errors.YAMLSemanticError(item, 'Separator , missing in flow map'));
-      key = doc.resolveNode(item);
-      keyStart = explicitKey ? null : item.range.start; // TODO: add error for non-explicit multiline plain key
-    } else {
-      if (next !== ',') doc.errors.push(new _errors.YAMLSemanticError(item, 'Indicator : missing in flow map entry'));
-      items.push(new _Pair.Pair(key, doc.resolveNode(item)));
-      key = undefined;
-      explicitKey = false;
-    }
-  }
-
-  (0, _parseUtils.checkFlowCollectionEnd)(doc.errors, cst);
-  if (key !== undefined) items.push(new _Pair.Pair(key));
-  return {
-    comments,
-    items
-  };
-}