yaml 1.8.2 → 1.9.2

package/dist/tags/yaml-1.1/set.js

@@ -1,43 +1,34 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = exports.YAMLSet = void 0;
+exports.set = exports.YAMLSet = void 0;
 
 var _errors = require("../../errors");
 
-var _Map = _interopRequireWildcard(require("../../schema/Map"));
+var _Map = require("../../schema/Map");
 
-var _Pair = _interopRequireDefault(require("../../schema/Pair"));
+var _Pair = require("../../schema/Pair");
 
-var _parseMap = _interopRequireDefault(require("../../schema/parseMap"));
+var _parseMap = require("../../schema/parseMap");
 
-var _Scalar = _interopRequireDefault(require("../../schema/Scalar"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
-
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var _Scalar = require("../../schema/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; }
 
-class YAMLSet extends _Map.default {
+class YAMLSet extends _Map.YAMLMap {
   constructor() {
     super();
     this.tag = YAMLSet.tag;
   }
 
   add(key) {
-    const pair = key instanceof _Pair.default ? key : new _Pair.default(key);
+    const pair = key instanceof _Pair.Pair ? key : new _Pair.Pair(key);
     const prev = (0, _Map.findPair)(this.items, pair.key);
     if (!prev) this.items.push(pair);
   }
 
   get(key, keepPair) {
     const pair = (0, _Map.findPair)(this.items, key);
-    return !keepPair && pair instanceof _Pair.default ? pair.key instanceof _Scalar.default ? pair.key.value : pair.key : pair;
+    return !keepPair && pair instanceof _Pair.Pair ? pair.key instanceof _Scalar.Scalar ? pair.key.value : pair.key : pair;
   }
 
   set(key, value) {
@@ -47,7 +38,7 @@ class YAMLSet extends _Map.default {
     if (prev && !value) {
       this.items.splice(this.items.indexOf(prev), 1);
     } else if (!prev && value) {
-      this.items.push(new _Pair.default(key));
+      this.items.push(new _Pair.Pair(key));
     }
   }
 
@@ -67,7 +58,7 @@ exports.YAMLSet = YAMLSet;
 _defineProperty(YAMLSet, "tag", 'tag:yaml.org,2002:set');
 
 function parseSet(doc, cst) {
-  const map = (0, _parseMap.default)(doc, cst);
+  const map = (0, _parseMap.parseMap)(doc, cst);
   if (!map.hasAllNullValues()) throw new _errors.YAMLSemanticError(cst, 'Set items must all have null values');
   return Object.assign(new YAMLSet(), map);
 }
@@ -80,7 +71,7 @@ function createSet(schema, iterable, ctx) {
   return set;
 }
 
-var _default = {
+const set = {
   identify: value => value instanceof Set,
   nodeClass: YAMLSet,
   default: false,
@@ -88,4 +79,4 @@ var _default = {
   resolve: parseSet,
   createNode: createSet
 };
-exports.default = _default;
+exports.set = set;

package/dist/tags/yaml-1.1/timestamp.js

@@ -1,8 +1,5 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
 exports.timestamp = exports.floatTime = exports.intTime = void 0;
 
 var _stringify = require("../../stringify");

package/dist/test-events.js

@@ -1,15 +1,10 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = testEvents;
+exports.testEvents = testEvents;
 
-var _parse = _interopRequireDefault(require("./cst/parse"));
+var _parse = require("./cst/parse");
 
-var _Document = _interopRequireDefault(require("./Document"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _Document = require("./Document");
 
 // test harness for yaml-test-suite event tests
 function testEvents(src, options) {
@@ -18,7 +13,7 @@ function testEvents(src, options) {
     keepNodeTypes: true,
     version: '1.2'
   }, options);
-  const docs = (0, _parse.default)(src).map(cstDoc => new _Document.default(opt).parse(cstDoc));
+  const docs = (0, _parse.parse)(src).map(cstDoc => new _Document.Document(opt).parse(cstDoc));
   const errDoc = docs.find(doc => doc.errors.length > 0);
   const error = errDoc ? errDoc.errors[0].message : null;
   const events = ['+STR'];

package/dist/toJSON.js

@@ -1,15 +1,12 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = toJSON;
+exports.toJSON = toJSON;
 
 function toJSON(value, arg, ctx) {
   if (Array.isArray(value)) return value.map((v, i) => toJSON(v, String(i), ctx));
 
   if (value && typeof value.toJSON === 'function') {
-    const anchor = ctx && ctx.anchors && ctx.anchors.find(a => a.node === value);
+    const anchor = ctx && ctx.anchors && ctx.anchors.get(value);
     if (anchor) ctx.onCreate = res => {
       anchor.res = res;
       delete ctx.onCreate;
@@ -19,5 +16,6 @@ function toJSON(value, arg, ctx) {
     return res;
   }
 
+  if ((!ctx || !ctx.keep) && typeof value === 'bigint') return Number(value);
   return value;
 }

package/dist/warnings.js

@@ -1,39 +1,48 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
 exports.warn = warn;
 exports.warnFileDeprecation = warnFileDeprecation;
 exports.warnOptionDeprecation = warnOptionDeprecation;
 
-/* global global, console */
+/* global console, process, YAML_SILENCE_DEPRECATION_WARNINGS, YAML_SILENCE_WARNINGS */
+function shouldWarn(deprecation) {
+  const env = typeof process !== 'undefined' && process.env || {};
+
+  if (deprecation) {
+    if (typeof YAML_SILENCE_DEPRECATION_WARNINGS !== 'undefined') return !YAML_SILENCE_DEPRECATION_WARNINGS;
+    return !env.YAML_SILENCE_DEPRECATION_WARNINGS;
+  }
+
+  if (typeof YAML_SILENCE_WARNINGS !== 'undefined') return !YAML_SILENCE_WARNINGS;
+  return !env.YAML_SILENCE_WARNINGS;
+}
+
 function warn(warning, type) {
-  if (global && global._YAML_SILENCE_WARNINGS) return;
-  const {
-    emitWarning
-  } = global && global.process; // This will throw in Jest if `warning` is an Error instance due to
-  // https://github.com/facebook/jest/issues/2549
-
-  if (emitWarning) emitWarning(warning, type);else {
-    // eslint-disable-next-line no-console
-    console.warn(type ? `${type}: ${warning}` : warning);
+  if (shouldWarn(false)) {
+    const emit = typeof process !== 'undefined' && process.emitWarning; // This will throw in Jest if `warning` is an Error instance due to
+    // https://github.com/facebook/jest/issues/2549
+
+    if (emit) emit(warning, type);else {
+      // eslint-disable-next-line no-console
+      console.warn(type ? `${type}: ${warning}` : warning);
+    }
   }
 }
 
 function warnFileDeprecation(filename) {
-  if (global && global._YAML_SILENCE_DEPRECATION_WARNINGS) return;
-  const path = filename.replace(/.*yaml[/\\]/i, '').replace(/\.js$/, '').replace(/\\/g, '/');
-  warn(`The endpoint 'yaml/${path}' will be removed in a future release.`, 'DeprecationWarning');
+  if (shouldWarn(true)) {
+    const path = filename.replace(/.*yaml[/\\]/i, '').replace(/\.js$/, '').replace(/\\/g, '/');
+    warn(`The endpoint 'yaml/${path}' will be removed in a future release.`, 'DeprecationWarning');
+  }
 }
 
 const warned = {};
 
 function warnOptionDeprecation(name, alternative) {
-  if (global && global._YAML_SILENCE_DEPRECATION_WARNINGS) return;
-  if (warned[name]) return;
-  warned[name] = true;
-  let msg = `The option '${name}' will be removed in a future release`;
-  msg += alternative ? `, use '${alternative}' instead.` : '.';
-  warn(msg, 'DeprecationWarning');
+  if (!warned[name] && shouldWarn(true)) {
+    warned[name] = true;
+    let msg = `The option '${name}' will be removed in a future release`;
+    msg += alternative ? `, use '${alternative}' instead.` : '.';
+    warn(msg, 'DeprecationWarning');
+  }
 }

package/index.d.ts

@@ -0,0 +1,358 @@
+import { CST } from './parse-cst'
+import { AST, Scalar, Schema, YAMLMap, YAMLSeq } from './types'
+import { Type, YAMLError, YAMLWarning } from './util'
+
+export { AST, CST }
+export { default as parseCST } from './parse-cst'
+
+/**
+ * `yaml` defines document-specific options in three places: as an argument of
+ * parse, create and stringify calls, in the values of `YAML.defaultOptions`,
+ * and in the version-dependent `YAML.Document.defaults` object. Values set in
+ * `YAML.defaultOptions` override version-dependent defaults, and argument
+ * options override both.
+ */
+export const defaultOptions: Options
+
+export interface Options extends Schema.Options {
+  /**
+   * Default prefix for anchors.
+   *
+   * Default: `'a'`, resulting in anchors `a1`, `a2`, etc.
+   */
+  anchorPrefix?: string
+  /**
+   * The number of spaces to use when indenting code.
+   *
+   * Default: `2`
+   */
+  indent?: number
+  /**
+   * Whether block sequences should be indented.
+   *
+   * Default: `true`
+   */
+  indentSeq?: boolean
+  /**
+   * Allow non-JSON JavaScript objects to remain in the `toJSON` output.
+   * Relevant with the YAML 1.1 `!!timestamp` and `!!binary` tags as well as BigInts.
+   *
+   * Default: `true`
+   */
+  keepBlobsInJSON?: boolean
+  /**
+   * Include references in the AST to each node's corresponding CST node.
+   *
+   * Default: `false`
+   */
+  keepCstNodes?: boolean
+  /**
+   * Store the original node type when parsing documents.
+   *
+   * Default: `true`
+   */
+  keepNodeTypes?: boolean
+  /**
+   * When outputting JS, use Map rather than Object to represent mappings.
+   *
+   * Default: `false`
+   */
+  mapAsMap?: boolean
+  /**
+   * Prevent exponential entity expansion attacks by limiting data aliasing count;
+   * set to `-1` to disable checks; `0` disallows all alias nodes.
+   *
+   * Default: `100`
+   */
+  maxAliasCount?: number
+  /**
+   * Include line position & node type directly in errors; drop their verbose source and context.
+   *
+   * Default: `false`
+   */
+  prettyErrors?: boolean
+  /**
+   * When stringifying, require keys to be scalars and to use implicit rather than explicit notation.
+   *
+   * Default: `false`
+   */
+  simpleKeys?: boolean
+  /**
+   * The YAML version used by documents without a `%YAML` directive.
+   *
+   * Default: `"1.2"`
+   */
+  version?: '1.0' | '1.1' | '1.2'
+}
+
+/**
+ * Some customization options are availabe to control the parsing and
+ * stringification of scalars. Note that these values are used by all documents.
+ */
+export const scalarOptions: {
+  binary: scalarOptions.Binary
+  bool: scalarOptions.Bool
+  int: scalarOptions.Int
+  null: scalarOptions.Null
+  str: scalarOptions.Str
+}
+export namespace scalarOptions {
+  interface Binary {
+    /**
+     * The type of string literal used to stringify `!!binary` values.
+     *
+     * Default: `'BLOCK_LITERAL'`
+     */
+    defaultType: Scalar.Type
+    /**
+     * Maximum line width for `!!binary`.
+     *
+     * Default: `76`
+     */
+    lineWidth: number
+  }
+
+  interface Bool {
+    /**
+     * String representation for `true`. With the core schema, use `'true' | 'True' | 'TRUE'`.
+     *
+     * Default: `'true'`
+     */
+    trueStr: string
+    /**
+     * String representation for `false`. With the core schema, use `'false' | 'False' | 'FALSE'`.
+     *
+     * Default: `'false'`
+     */
+    falseStr: string
+  }
+
+  interface Int {
+    /**
+     * Whether integers should be parsed into BigInt values.
+     *
+     * Default: `false`
+     */
+    asBigInt: false
+  }
+
+  interface Null {
+    /**
+     * String representation for `null`. With the core schema, use `'null' | 'Null' | 'NULL' | '~' | ''`.
+     *
+     * Default: `'null'`
+     */
+    nullStr: string
+  }
+
+  interface Str {
+    /**
+     * The default type of string literal used to stringify values
+     *
+     * Default: `'PLAIN'`
+     */
+    defaultType: Scalar.Type
+    doubleQuoted: {
+      /**
+       * Whether to restrict double-quoted strings to use JSON-compatible syntax.
+       *
+       * Default: `false`
+       */
+      jsonEncoding: boolean
+      /**
+       * Minimum length to use multiple lines to represent the value.
+       *
+       * Default: `40`
+       */
+      minMultiLineLength: number
+    }
+    fold: {
+      /**
+       * Maximum line width (set to `0` to disable folding).
+       *
+       * Default: `80`
+       */
+      lineWidth: number
+      /**
+       * Minimum width for highly-indented content.
+       *
+       * Default: `20`
+       */
+      minContentWidth: number
+    }
+  }
+}
+
+export class Document extends AST.Collection {
+  cstNode?: CST.Document
+  constructor(options?: Options)
+  tag: never
+  type: Type.DOCUMENT
+  /**
+   * Anchors associated with the document's nodes;
+   * also provides alias & merge node creators.
+   */
+  anchors: Document.Anchors
+  /** The document contents. */
+  contents: AST.AstNode | null
+  /** Errors encountered during parsing. */
+  errors: YAMLError[]
+  /**
+   * The schema used with the document. Use `setSchema()` to change or
+   * initialise.
+   */
+  schema?: Schema
+  /**
+   * Array of prefixes; each will have a string `handle` that
+   * starts and ends with `!` and a string `prefix` that the handle will be replaced by.
+   */
+  tagPrefixes: Document.TagPrefix[]
+  /**
+   * The parsed version of the source document;
+   * if true-ish, stringified output will include a `%YAML` directive.
+   */
+  version?: string
+  /** Warnings encountered during parsing. */
+  warnings: YAMLWarning[]
+  /**
+   * List the tags used in the document that are not in the default
+   * `tag:yaml.org,2002:` namespace.
+   */
+  listNonDefaultTags(): string[]
+  /** Parse a CST into this document */
+  parse(cst: CST.Document): this
+  /**
+   * When a document is created with `new YAML.Document()`, the schema object is
+   * not set as it may be influenced by parsed directives; call this with no
+   * arguments to set it manually, or with arguments to change the schema used
+   * by the document.
+   **/
+  setSchema(
+    id?: Options['version'] | Schema.Name,
+    customTags?: (Schema.TagId | Schema.Tag)[]
+  ): void
+  /** Set `handle` as a shorthand string for the `prefix` tag namespace. */
+  setTagPrefix(handle: string, prefix: string): void
+  /**
+   * A plain JavaScript representation of the document `contents`.
+   *
+   * @param arg Used by `JSON.stringify` to indicate the array index or property
+   *   name. If its value is a `string` and the document `contents` has a scalar
+   *   value, the `keepBlobsInJSON` option has no effect.
+   * @param onAnchor If defined, called with the resolved `value` and reference
+   *   `count` for each anchor in the document.
+   * */
+  toJSON(arg?: string, onAnchor?: (value: any, count: number) => void): any
+  /** A YAML representation of the document. */
+  toString(): string
+}
+
+export namespace Document {
+  interface Parsed extends Document {
+    /** The schema used with the document. */
+    schema: Schema
+  }
+
+  interface Anchors {
+    /**
+     * Create a new `Alias` node, adding the required anchor for `node`.
+     * If `name` is empty, a new anchor name will be generated.
+     */
+    createAlias(node: AST.Node, name?: string): AST.Alias
+    /**
+     * Create a new `Merge` node with the given source nodes.
+     * Non-`Alias` sources will be automatically wrapped.
+     */
+    createMergePair(...nodes: AST.Node[]): AST.Merge
+    /** The anchor name associated with `node`, if set. */
+    getName(node: AST.Node): undefined | string
+    /** The node associated with the anchor `name`, if set. */
+    getNode(name: string): undefined | AST.Node
+    /**
+     * Find an available anchor name with the given `prefix` and a
+     * numerical suffix.
+     */
+    newName(prefix: string): string
+    /**
+     * 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: AST.Node | null, name?: string): void | string
+  }
+
+  interface TagPrefix {
+    handle: string
+    prefix: string
+  }
+}
+
+/**
+ * Recursively turns objects into collections. Generic objects as well as `Map`
+ * and its descendants become mappings, while arrays and other iterable objects
+ * result in sequences.
+ *
+ * The primary purpose of this function is to enable attaching comments or other
+ * metadata to a value, or to otherwise exert more fine-grained control over the
+ * stringified output. To that end, you'll need to assign its return value to
+ * the `contents` of a Document (or somewhere within said contents), as the
+ * document's schema is required for YAML string output.
+ *
+ * @param wrapScalars If undefined or `true`, also wraps plain values in
+ *   `Scalar` objects; if `false` and `value` is not an object, it will be
+ *   returned directly.
+ * @param tag Use to specify the collection type, e.g. `"!!omap"`. Note that
+ *   this requires the corresponding tag to be available based on the default
+ *   options. To use a specific document's schema, use `doc.schema.createNode`.
+ */
+export function createNode(
+  value: any,
+  wrapScalars?: true,
+  tag?: string
+): YAMLMap | YAMLSeq | Scalar
+
+/**
+ * YAML.createNode recursively turns objects into Map and arrays to Seq collections.
+ * Its primary use is to enable attaching comments or other metadata to a value,
+ * or to otherwise exert more fine-grained control over the stringified output.
+ *
+ * Doesn't wrap plain values in Scalar objects.
+ */
+export function createNode(
+  value: any,
+  wrapScalars: false,
+  tag?: string
+): YAMLMap | YAMLSeq | string | number | boolean | null
+
+/**
+ * Parse an input string into a single YAML.Document.
+ */
+export function parseDocument(str: string, options?: Options): Document.Parsed
+
+/**
+ * Parse the input as a stream of YAML documents.
+ *
+ * Documents should be separated from each other by `...` or `---` marker lines.
+ */
+export function parseAllDocuments(
+  str: string,
+  options?: Options
+): Document.Parsed[]
+
+/**
+ * Parse an input string into JavaScript.
+ *
+ * Only supports input consisting of a single YAML document; for multi-document
+ * support you should use `YAML.parseAllDocuments`. May throw on error, and may
+ * log warnings using `console.warn`.
+ *
+ * @param str A string with YAML formatting.
+ * @returns The value will match the type of the root value of the parsed YAML
+ *   document, so Maps become objects, Sequences arrays, and scalars result in
+ *   nulls, booleans, numbers and strings.
+ */
+export function parse(str: string, options?: Options): any
+
+/**
+ * @returns Will always include \n as the last character, as is expected of YAML documents.
+ */
+export function stringify(value: any, options?: Options): string

package/index.js

@@ -1 +1 @@
-module.exports = require('./dist').default
+module.exports = require('./dist').YAML

package/map.js

@@ -1,2 +1,2 @@
-module.exports = require('./dist/schema/Map').default
+module.exports = require('./dist/schema/Map').YAMLMap
 require('./dist/warnings').warnFileDeprecation(__filename)