yaml 2.0.0-2 → 2.0.0-6

package/browser/dist/ast/YAMLMap.js

@@ -1,91 +0,0 @@
-import { Collection } from './Collection.js';
-import { Pair } from './Pair.js';
-import { Scalar, isScalarValue } from './Scalar.js';
-
-function findPair(items, key) {
-  const k = key instanceof Scalar ? key.value : key;
-
-  for (const it of items) {
-    if (it instanceof Pair) {
-      if (it.key === key || it.key === k) return it;
-      if (it.key && it.key.value === k) return it;
-    }
-  }
-
-  return undefined;
-}
-class YAMLMap extends Collection {
-  add(pair, overwrite) {
-    if (!pair) pair = new Pair(pair);else if (!(pair instanceof Pair)) pair = new Pair(pair.key || pair, pair.value);
-    const prev = findPair(this.items, pair.key);
-    const sortEntries = this.schema && this.schema.sortMapEntries;
-
-    if (prev) {
-      if (!overwrite) throw new Error("Key ".concat(pair.key, " already set")); // For scalars, keep the old node & its comments and anchors
-
-      if (prev.value instanceof Scalar && isScalarValue(pair.value)) prev.value.value = pair.value;else prev.value = pair.value;
-    } else if (sortEntries) {
-      const i = this.items.findIndex(item => sortEntries(pair, item) < 0);
-      if (i === -1) this.items.push(pair);else this.items.splice(i, 0, pair);
-    } else {
-      this.items.push(pair);
-    }
-  }
-
-  delete(key) {
-    const it = findPair(this.items, key);
-    if (!it) return false;
-    const del = this.items.splice(this.items.indexOf(it), 1);
-    return del.length > 0;
-  }
-
-  get(key, keepScalar) {
-    const it = findPair(this.items, key);
-    const node = it && it.value;
-    return !keepScalar && node instanceof Scalar ? node.value : node;
-  }
-
-  has(key) {
-    return !!findPair(this.items, key);
-  }
-
-  set(key, value) {
-    this.add(new Pair(key, value), true);
-  }
-  /**
-   * @param ctx - Conversion context, originally set in Document#toJS()
-   * @param {Class} Type - If set, forces the returned collection type
-   * @returns Instance of Type, Map, or Object
-   */
-
-
-  toJSON(_, ctx, Type) {
-    const map = Type ? new Type() : ctx && ctx.mapAsMap ? new Map() : {};
-    if (ctx && ctx.onCreate) ctx.onCreate(map);
-
-    for (const item of this.items) item.addToJSMap(ctx, map);
-
-    return map;
-  }
-
-  toString(ctx, onComment, onChompKeep) {
-    if (!ctx) return JSON.stringify(this);
-
-    for (const item of this.items) {
-      if (!(item instanceof Pair)) throw new Error("Map items must all be pairs; found ".concat(JSON.stringify(item), " instead"));
-    }
-
-    return super.toString(ctx, {
-      blockItem: n => n.str,
-      flowChars: {
-        start: '{',
-        end: '}'
-      },
-      isMap: true,
-      itemIndent: ctx.indent || ''
-    }, onComment, onChompKeep);
-  }
-
-}
-
-export { YAMLMap, findPair };

package/browser/dist/ast/YAMLSeq.js

@@ -1,67 +0,0 @@
-import { Collection } from './Collection.js';
-import { Scalar, isScalarValue } from './Scalar.js';
-import { toJS } from './toJS.js';
-
-function asItemIndex(key) {
-  let idx = key instanceof Scalar ? key.value : key;
-  if (idx && typeof idx === 'string') idx = Number(idx);
-  return Number.isInteger(idx) && idx >= 0 ? idx : null;
-}
-
-class YAMLSeq extends Collection {
-  add(value) {
-    this.items.push(value);
-  }
-
-  delete(key) {
-    const idx = asItemIndex(key);
-    if (typeof idx !== 'number') return false;
-    const del = this.items.splice(idx, 1);
-    return del.length > 0;
-  }
-
-  get(key, keepScalar) {
-    const idx = asItemIndex(key);
-    if (typeof idx !== 'number') return undefined;
-    const it = this.items[idx];
-    return !keepScalar && it instanceof Scalar ? it.value : it;
-  }
-
-  has(key) {
-    const idx = asItemIndex(key);
-    return typeof idx === 'number' && idx < this.items.length;
-  }
-
-  set(key, value) {
-    const idx = asItemIndex(key);
-    if (typeof idx !== 'number') throw new Error("Expected a valid index, not ".concat(key, "."));
-    const prev = this.items[idx];
-    if (prev instanceof Scalar && isScalarValue(value)) prev.value = value;else this.items[idx] = value;
-  }
-
-  toJSON(_, ctx) {
-    const seq = [];
-    if (ctx && ctx.onCreate) ctx.onCreate(seq);
-    let i = 0;
-
-    for (const item of this.items) seq.push(toJS(item, String(i++), ctx));
-
-    return seq;
-  }
-
-  toString(ctx, onComment, onChompKeep) {
-    if (!ctx) return JSON.stringify(this);
-    return super.toString(ctx, {
-      blockItem: n => n.type === 'comment' ? n.str : "- ".concat(n.str),
-      flowChars: {
-        start: '[',
-        end: ']'
-      },
-      isMap: false,
-      itemIndent: (ctx.indent || '') + '  '
-    }, onComment, onChompKeep);
-  }
-
-}
-
-export { YAMLSeq };

package/browser/dist/ast/toJS.js

@@ -1,29 +0,0 @@
-/**
- * Recursively convert any node or its contents to native JavaScript
- *
- * @param value - The input value
- * @param {string|null} arg - If `value` defines a `toJSON()` method, use this
- *   as its first argument
- * @param ctx - Conversion context, originally set in Document#toJS(). If
- *   `{ keep: true }` is not set, output should be suitable for JSON
- *   stringification.
- */
-function toJS(value, arg, ctx) {
-  if (Array.isArray(value)) return value.map((v, i) => toJS(v, String(i), ctx));
-
-  if (value && typeof value.toJSON === 'function') {
-    const anchor = ctx && ctx.anchors && ctx.anchors.get(value);
-    if (anchor) ctx.onCreate = res => {
-      anchor.res = res;
-      delete ctx.onCreate;
-    };
-    const res = value.toJSON(arg, ctx);
-    if (anchor && ctx.onCreate) ctx.onCreate(res);
-    return res;
-  }
-
-  if (!(ctx && ctx.keep) && typeof value === 'bigint') return Number(value);
-  return value;
-}
-
-export { toJS };

package/browser/dist/ast/visit.js

@@ -1,83 +0,0 @@
-import { Type } from '../constants.js';
-import { Alias } from './Alias.js';
-import { Node } from './Node.js';
-import { Pair } from './Pair.js';
-import { Scalar } from './Scalar.js';
-import { YAMLMap } from './YAMLMap.js';
-import { YAMLSeq } from './YAMLSeq.js';
-
-const BREAK = Symbol('break visit');
-const SKIP = Symbol('skip children');
-const REMOVE = Symbol('remove node');
-
-function _visit(key, node, visitor, path) {
-  let ctrl = undefined;
-  if (typeof visitor === 'function') ctrl = visitor(key, node, path);else if (node instanceof YAMLMap) {
-    if (visitor.Map) ctrl = visitor.Map(key, node, path);
-  } else if (node instanceof YAMLSeq) {
-    if (visitor.Seq) ctrl = visitor.Seq(key, node, path);
-  } else if (node instanceof Pair) {
-    if (visitor.Pair) ctrl = visitor.Pair(key, node, path);
-  } else if (node instanceof Scalar) {
-    if (visitor.Scalar) ctrl = visitor.Scalar(key, node, path);
-  } else if (node instanceof Alias) {
-    if (visitor.Scalar) ctrl = visitor.Alias(key, node, path);
-  }
-
-  if (ctrl instanceof Node) {
-    const parent = path[path.length - 1];
-
-    if (parent instanceof YAMLMap || parent instanceof YAMLSeq) {
-      parent.items[key] = ctrl;
-    } else if (parent instanceof Pair) {
-      if (key === 'key') parent.key = ctrl;else parent.value = ctrl;
-    } else if (parent && parent.type === Type.DOCUMENT) {
-      parent.contents = ctrl;
-    } else {
-      const pt = parent && parent.type;
-      throw new Error("Cannot replace node with ".concat(pt, " parent"));
-    }
-
-    return _visit(key, ctrl, visitor, path);
-  }
-
-  if (typeof ctrl !== 'symbol') {
-    if (node instanceof YAMLMap || node instanceof YAMLSeq) {
-      path = Object.freeze(path.concat(node));
-
-      for (let i = 0; i < node.items.length; ++i) {
-        const ci = _visit(i, node.items[i], visitor, path);
-
-        if (typeof ci === 'number') i = ci - 1;else if (ci === BREAK) return BREAK;else if (ci === REMOVE) {
-          node.items.splice(i, 1);
-          i -= 1;
-        }
-      }
-    } else if (node instanceof Pair) {
-      path = Object.freeze(path.concat(node));
-
-      const ck = _visit('key', node.key, visitor, path);
-
-      if (ck === BREAK) return BREAK;else if (ck === REMOVE) node.key = null;
-
-      const cv = _visit('value', node.value, visitor, path);
-
-      if (cv === BREAK) return BREAK;else if (cv === REMOVE) node.value = null;
-    }
-  }
-
-  return ctrl;
-}
-
-function visit(node, visitor) {
-  if (node && node.type === Type.DOCUMENT) {
-    const cd = _visit(null, node.contents, visitor, Object.freeze([node]));
-
-    if (cd === REMOVE) node.contents = null;
-  } else _visit(null, node, visitor, Object.freeze([]));
-}
-visit.BREAK = BREAK;
-visit.SKIP = SKIP;
-visit.REMOVE = REMOVE;
-
-export { visit };

package/browser/dist/constants.js

@@ -1,40 +0,0 @@
-const Char = {
-  ANCHOR: '&',
-  COMMENT: '#',
-  TAG: '!',
-  DIRECTIVES_END: '-',
-  DOCUMENT_END: '.'
-};
-const LogLevel = Object.assign(['silent', 'error', 'warn', 'debug'], {
-  SILENT: 0,
-  ERROR: 1,
-  WARN: 2,
-  DEBUG: 3
-});
-const Type = {
-  ALIAS: 'ALIAS',
-  BLANK_LINE: 'BLANK_LINE',
-  BLOCK_FOLDED: 'BLOCK_FOLDED',
-  BLOCK_LITERAL: 'BLOCK_LITERAL',
-  COMMENT: 'COMMENT',
-  DIRECTIVE: 'DIRECTIVE',
-  DOCUMENT: 'DOCUMENT',
-  FLOW_MAP: 'FLOW_MAP',
-  FLOW_SEQ: 'FLOW_SEQ',
-  MAP: 'MAP',
-  MAP_KEY: 'MAP_KEY',
-  MAP_VALUE: 'MAP_VALUE',
-  PLAIN: 'PLAIN',
-  QUOTE_DOUBLE: 'QUOTE_DOUBLE',
-  QUOTE_SINGLE: 'QUOTE_SINGLE',
-  SEQ: 'SEQ',
-  SEQ_ITEM: 'SEQ_ITEM'
-};
-const defaultTagPrefix = 'tag:yaml.org,2002:';
-const defaultTags = {
-  MAP: 'tag:yaml.org,2002:map',
-  SEQ: 'tag:yaml.org,2002:seq',
-  STR: 'tag:yaml.org,2002:str'
-};
-
-export { Char, LogLevel, Type, defaultTagPrefix, defaultTags };

package/browser/dist/cst/Alias.js

@@ -1,26 +0,0 @@
-import { Node } from './Node.js';
-import { Range } from './Range.js';
-
-class Alias extends Node {
-  /**
-   * Parses an *alias from the source
-   *
-   * @param {ParseContext} context
-   * @param {number} start - Index of first character
-   * @returns {number} - Index of the character after this scalar
-   */
-  parse(context, start) {
-    this.context = context;
-    const {
-      src
-    } = context;
-    let offset = Node.endOfIdentifier(src, start + 1);
-    this.valueRange = new Range(start + 1, offset);
-    offset = Node.endOfWhiteSpace(src, offset);
-    offset = this.parseComment(offset);
-    return offset;
-  }
-
-}
-
-export { Alias };

package/browser/dist/cst/BlankLine.js

@@ -1,34 +0,0 @@
-import { Type } from '../constants.js';
-import { Node } from './Node.js';
-import { Range } from './Range.js';
-
-class BlankLine extends Node {
-  constructor() {
-    super(Type.BLANK_LINE);
-  }
-  /* istanbul ignore next */
-
-
-  get includesTrailingLines() {
-    // This is never called from anywhere, but if it were,
-    // this is the value it should return.
-    return true;
-  }
-  /**
-   * Parses a blank line from the source
-   *
-   * @param {ParseContext} context
-   * @param {number} start - Index of first \n character
-   * @returns {number} - Index of the character after this
-   */
-
-
-  parse(context, start) {
-    this.context = context;
-    this.range = new Range(start, start + 1);
-    return start + 1;
-  }
-
-}
-
-export { BlankLine };

package/browser/dist/cst/BlockValue.js

@@ -1,240 +0,0 @@
-import { Type } from '../constants.js';
-import { YAMLSemanticError } from '../errors.js';
-import { Node } from './Node.js';
-import { Range } from './Range.js';
-
-const Chomp = {
-  CLIP: 'CLIP',
-  KEEP: 'KEEP',
-  STRIP: 'STRIP'
-};
-class BlockValue extends Node {
-  constructor(type, props) {
-    super(type, props);
-    this.blockIndent = null;
-    this.chomping = Chomp.CLIP;
-    this.header = null;
-  }
-
-  get includesTrailingLines() {
-    return this.chomping === Chomp.KEEP;
-  }
-
-  get strValue() {
-    if (!this.valueRange || !this.context) return null;
-    let {
-      start,
-      end
-    } = this.valueRange;
-    const {
-      indent,
-      src
-    } = this.context;
-    if (this.valueRange.isEmpty()) return '';
-    let lastNewLine = null;
-    let ch = src[end - 1];
-
-    while (ch === '\n' || ch === '\t' || ch === ' ') {
-      end -= 1;
-
-      if (end <= start) {
-        if (this.chomping === Chomp.KEEP) break;else return ''; // probably never happens
-      }
-
-      if (ch === '\n') lastNewLine = end;
-      ch = src[end - 1];
-    }
-
-    let keepStart = end + 1;
-
-    if (lastNewLine) {
-      if (this.chomping === Chomp.KEEP) {
-        keepStart = lastNewLine;
-        end = this.valueRange.end;
-      } else {
-        end = lastNewLine;
-      }
-    }
-
-    const bi = indent + this.blockIndent;
-    const folded = this.type === Type.BLOCK_FOLDED;
-    let atStart = true;
-    let str = '';
-    let sep = '';
-    let prevMoreIndented = false;
-
-    for (let i = start; i < end; ++i) {
-      for (let j = 0; j < bi; ++j) {
-        if (src[i] !== ' ') break;
-        i += 1;
-      }
-
-      const ch = src[i];
-
-      if (ch === '\n') {
-        if (sep === '\n') str += '\n';else sep = '\n';
-      } else {
-        const lineEnd = Node.endOfLine(src, i);
-        const line = src.slice(i, lineEnd);
-        i = lineEnd;
-
-        if (folded && (ch === ' ' || ch === '\t') && i < keepStart) {
-          if (sep === ' ') sep = '\n';else if (!prevMoreIndented && !atStart && sep === '\n') sep = '\n\n';
-          str += sep + line; //+ ((lineEnd < end && src[lineEnd]) || '')
-
-          sep = lineEnd < end && src[lineEnd] || '';
-          prevMoreIndented = true;
-        } else {
-          str += sep + line;
-          sep = folded && i < keepStart ? ' ' : '\n';
-          prevMoreIndented = false;
-        }
-
-        if (atStart && line !== '') atStart = false;
-      }
-    }
-
-    return this.chomping === Chomp.STRIP ? str : str + '\n';
-  }
-
-  parseBlockHeader(start) {
-    const {
-      src
-    } = this.context;
-    let offset = start + 1;
-    let bi = '';
-
-    while (true) {
-      const ch = src[offset];
-
-      switch (ch) {
-        case '-':
-          this.chomping = Chomp.STRIP;
-          break;
-
-        case '+':
-          this.chomping = Chomp.KEEP;
-          break;
-
-        case '0':
-        case '1':
-        case '2':
-        case '3':
-        case '4':
-        case '5':
-        case '6':
-        case '7':
-        case '8':
-        case '9':
-          bi += ch;
-          break;
-
-        default:
-          this.blockIndent = Number(bi) || null;
-          this.header = new Range(start, offset);
-          return offset;
-      }
-
-      offset += 1;
-    }
-  }
-
-  parseBlockValue(start) {
-    const {
-      indent,
-      src
-    } = this.context;
-    const explicit = !!this.blockIndent;
-    let offset = start;
-    let valueEnd = start;
-    let minBlockIndent = 1;
-
-    for (let ch = src[offset]; ch === '\n'; ch = src[offset]) {
-      offset += 1;
-      if (Node.atDocumentBoundary(src, offset)) break;
-      const end = Node.endOfBlockIndent(src, indent, offset); // should not include tab?
-
-      if (end === null) break;
-      const ch = src[end];
-      const lineIndent = end - (offset + indent);
-
-      if (!this.blockIndent) {
-        // no explicit block indent, none yet detected
-        if (src[end] !== '\n') {
-          // first line with non-whitespace content
-          if (lineIndent < minBlockIndent) {
-            const msg = 'Block scalars with more-indented leading empty lines must use an explicit indentation indicator';
-            this.error = new YAMLSemanticError(this, msg);
-          }
-
-          this.blockIndent = lineIndent;
-        } else if (lineIndent > minBlockIndent) {
-          // empty line with more whitespace
-          minBlockIndent = lineIndent;
-        }
-      } else if (ch && ch !== '\n' && lineIndent < this.blockIndent) {
-        if (src[end] === '#') break;
-
-        if (!this.error) {
-          const src = explicit ? 'explicit indentation indicator' : 'first line';
-          const msg = "Block scalars must not be less indented than their ".concat(src);
-          this.error = new YAMLSemanticError(this, msg);
-        }
-      }
-
-      if (src[end] === '\n') {
-        offset = end;
-      } else {
-        offset = valueEnd = Node.endOfLine(src, end);
-      }
-    }
-
-    if (this.chomping !== Chomp.KEEP) {
-      offset = src[valueEnd] ? valueEnd + 1 : valueEnd;
-    }
-
-    this.valueRange = new Range(start + 1, offset);
-    return offset;
-  }
-  /**
-   * Parses a block value from the source
-   *
-   * Accepted forms are:
-   * ```
-   * BS
-   * block
-   * lines
-   *
-   * BS #comment
-   * block
-   * lines
-   * ```
-   * where the block style BS matches the regexp `[|>][-+1-9]*` and block lines
-   * are empty or have an indent level greater than `indent`.
-   *
-   * @param {ParseContext} context
-   * @param {number} start - Index of first character
-   * @returns {number} - Index of the character after this block
-   */
-
-
-  parse(context, start) {
-    this.context = context;
-    const {
-      src
-    } = context;
-    let offset = this.parseBlockHeader(start);
-    offset = Node.endOfWhiteSpace(src, offset);
-    offset = this.parseComment(offset);
-    offset = this.parseBlockValue(offset);
-    return offset;
-  }
-
-  setOrigRanges(cr, offset) {
-    offset = super.setOrigRanges(cr, offset);
-    return this.header ? this.header.setOrigRange(cr, offset) : offset;
-  }
-
-}
-
-export { BlockValue, Chomp };