yaml 1.6.0 → 1.8.0

package/browser/dist/cst/QuoteSingle.js

@@ -1,39 +1,22 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-
-var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
-
-var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
-
-var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
-
-var _errors = require("../errors");
-
-var _Node2 = _interopRequireDefault(require("./Node"));
-
-var _Range = _interopRequireDefault(require("./Range"));
-
-var QuoteSingle =
-/*#__PURE__*/
-function (_Node) {
-  (0, _inherits2.default)(QuoteSingle, _Node);
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+import { YAMLSemanticError, YAMLSyntaxError } from '../errors';
+import Node from './Node';
+import Range from './Range';
+
+var QuoteSingle = /*#__PURE__*/function (_Node) {
+  _inherits(QuoteSingle, _Node);
 
   function QuoteSingle() {
-    (0, _classCallCheck2.default)(this, QuoteSingle);
-    return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(QuoteSingle).apply(this, arguments));
+    _classCallCheck(this, QuoteSingle);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(QuoteSingle).apply(this, arguments));
   }
 
-  (0, _createClass2.default)(QuoteSingle, [{
+  _createClass(QuoteSingle, [{
     key: "parse",
 
     /**
@@ -47,8 +30,8 @@ function (_Node) {
       this.context = context;
       var src = context.src;
       var offset = QuoteSingle.endOfQuote(src, start + 1);
-      this.valueRange = new _Range.default(start, offset);
-      offset = _Node2.default.endOfWhiteSpace(src, offset);
+      this.valueRange = new Range(start, offset);
+      offset = Node.endOfWhiteSpace(src, offset);
       offset = this.parseComment(offset);
       return offset;
     }
@@ -67,27 +50,27 @@ function (_Node) {
       var _this$context = this.context,
           indent = _this$context.indent,
           src = _this$context.src;
-      if (src[end - 1] !== "'") errors.push(new _errors.YAMLSyntaxError(this, "Missing closing 'quote"));
+      if (src[end - 1] !== "'") errors.push(new YAMLSyntaxError(this, "Missing closing 'quote"));
       var str = '';
 
       for (var i = start + 1; i < end - 1; ++i) {
         var ch = src[i];
 
         if (ch === '\n') {
-          if (_Node2.default.atDocumentBoundary(src, i + 1)) errors.push(new _errors.YAMLSemanticError(this, 'Document boundary indicators are not allowed within string values'));
+          if (Node.atDocumentBoundary(src, i + 1)) errors.push(new YAMLSemanticError(this, 'Document boundary indicators are not allowed within string values'));
 
-          var _Node$foldNewline = _Node2.default.foldNewline(src, i, indent),
+          var _Node$foldNewline = Node.foldNewline(src, i, indent),
               fold = _Node$foldNewline.fold,
               offset = _Node$foldNewline.offset,
               error = _Node$foldNewline.error;
 
           str += fold;
           i = offset;
-          if (error) errors.push(new _errors.YAMLSemanticError(this, 'Multi-line single-quoted string needs to be sufficiently indented'));
+          if (error) errors.push(new YAMLSemanticError(this, 'Multi-line single-quoted string needs to be sufficiently indented'));
         } else if (ch === "'") {
           str += ch;
           i += 1;
-          if (src[i] !== "'") errors.push(new _errors.YAMLSyntaxError(this, 'Unescaped single quote? This should not happen.'));
+          if (src[i] !== "'") errors.push(new YAMLSyntaxError(this, 'Unescaped single quote? This should not happen.'));
         } else if (ch === ' ' || ch === '\t') {
           // trim trailing whitespace
           var wsStart = i;
@@ -126,7 +109,8 @@ function (_Node) {
       return offset + 1;
     }
   }]);
+
   return QuoteSingle;
-}(_Node2.default);
+}(Node);
 
-exports.default = QuoteSingle;
+export { QuoteSingle as default };

package/browser/dist/cst/Range.js

@@ -1,20 +1,8 @@
-"use strict";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-
-var Range =
-/*#__PURE__*/
-function () {
-  (0, _createClass2.default)(Range, null, [{
+var Range = /*#__PURE__*/function () {
+  _createClass(Range, null, [{
     key: "copy",
     value: function copy(orig) {
       return new Range(orig.start, orig.end);
@@ -22,12 +10,13 @@ function () {
   }]);
 
   function Range(start, end) {
-    (0, _classCallCheck2.default)(this, Range);
+    _classCallCheck(this, Range);
+
     this.start = start;
     this.end = end || start;
   }
 
-  (0, _createClass2.default)(Range, [{
+  _createClass(Range, [{
     key: "isEmpty",
     value: function isEmpty() {
       return typeof this.start !== 'number' || !this.end || this.end <= this.start;
@@ -71,7 +60,8 @@ function () {
       return nextOffset;
     }
   }]);
+
   return Range;
 }();
 
-exports.default = Range;
+export { Range as default };

package/browser/dist/cst/parse.js

@@ -1,18 +1,7 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = parse;
-
-var _Document = _interopRequireDefault(require("./Document"));
-
-var _ParseContext = _interopRequireDefault(require("./ParseContext"));
-
 // Published as 'yaml/parse-cst'
-function parse(src) {
+import Document from './Document';
+import ParseContext from './ParseContext';
+export default function parse(src) {
   var cr = [];
 
   if (src.indexOf('\r') !== -1) {
@@ -26,8 +15,8 @@ function parse(src) {
   var offset = 0;
 
   do {
-    var doc = new _Document.default();
-    var context = new _ParseContext.default({
+    var doc = new Document();
+    var context = new ParseContext({
       src: src
     });
     offset = doc.parse(context, offset);

package/browser/dist/cst/source-utils.js

@@ -0,0 +1,168 @@
+function findLineStarts(src) {
+  var ls = [0];
+  var offset = src.indexOf('\n');
+
+  while (offset !== -1) {
+    offset += 1;
+    ls.push(offset);
+    offset = src.indexOf('\n', offset);
+  }
+
+  return ls;
+}
+
+function getSrcInfo(cst) {
+  var lineStarts, src;
+
+  if (typeof cst === 'string') {
+    lineStarts = findLineStarts(cst);
+    src = cst;
+  } else {
+    if (Array.isArray(cst)) cst = cst[0];
+
+    if (cst && cst.context) {
+      if (!cst.lineStarts) cst.lineStarts = findLineStarts(cst.context.src);
+      lineStarts = cst.lineStarts;
+      src = cst.context.src;
+    }
+  }
+
+  return {
+    lineStarts: lineStarts,
+    src: src
+  };
+}
+/**
+ * @typedef {Object} LinePos - One-indexed position in the source
+ * @property {number} line
+ * @property {number} col
+ */
+
+/**
+ * Determine the line/col position matching a character offset.
+ *
+ * Accepts a source string or a CST document as the second parameter. With
+ * the latter, starting indices for lines are cached in the document as
+ * `lineStarts: number[]`.
+ *
+ * Returns a one-indexed `{ line, col }` location if found, or
+ * `undefined` otherwise.
+ *
+ * @param {number} offset
+ * @param {string|Document|Document[]} cst
+ * @returns {?LinePos}
+ */
+
+
+export function getLinePos(offset, cst) {
+  if (typeof offset !== 'number' || offset < 0) return null;
+
+  var _getSrcInfo = getSrcInfo(cst),
+      lineStarts = _getSrcInfo.lineStarts,
+      src = _getSrcInfo.src;
+
+  if (!lineStarts || !src || offset > src.length) return null;
+
+  for (var i = 0; i < lineStarts.length; ++i) {
+    var start = lineStarts[i];
+
+    if (offset < start) {
+      return {
+        line: i,
+        col: offset - lineStarts[i - 1] + 1
+      };
+    }
+
+    if (offset === start) return {
+      line: i + 1,
+      col: 1
+    };
+  }
+
+  var line = lineStarts.length;
+  return {
+    line: line,
+    col: offset - lineStarts[line - 1] + 1
+  };
+}
+/**
+ * Get a specified line from the source.
+ *
+ * Accepts a source string or a CST document as the second parameter. With
+ * the latter, starting indices for lines are cached in the document as
+ * `lineStarts: number[]`.
+ *
+ * Returns the line as a string if found, or `null` otherwise.
+ *
+ * @param {number} line One-indexed line number
+ * @param {string|Document|Document[]} cst
+ * @returns {?string}
+ */
+
+export function getLine(line, cst) {
+  var _getSrcInfo2 = getSrcInfo(cst),
+      lineStarts = _getSrcInfo2.lineStarts,
+      src = _getSrcInfo2.src;
+
+  if (!lineStarts || !(line >= 1) || line > lineStarts.length) return null;
+  var start = lineStarts[line - 1];
+  var end = lineStarts[line]; // undefined for last line; that's ok for slice()
+
+  while (end && end > start && src[end - 1] === '\n') {
+    --end;
+  }
+
+  return src.slice(start, end);
+}
+/**
+ * Pretty-print the starting line from the source indicated by the range `pos`
+ *
+ * Trims output to `maxWidth` chars while keeping the starting column visible,
+ * using `…` at either end to indicate dropped characters.
+ *
+ * Returns a two-line string (or `null`) with `\n` as separator; the second line
+ * will hold appropriately indented `^` marks indicating the column range.
+ *
+ * @param {Object} pos
+ * @param {LinePos} pos.start
+ * @param {LinePos} [pos.end]
+ * @param {string|Document|Document[]*} cst
+ * @param {number} [maxWidth=80]
+ * @returns {?string}
+ */
+
+export function getPrettyContext(_ref, cst) {
+  var start = _ref.start,
+      end = _ref.end;
+  var maxWidth = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 80;
+  var src = getLine(start.line, cst);
+  if (!src) return null;
+  var col = start.col;
+
+  if (src.length > maxWidth) {
+    if (col <= maxWidth - 10) {
+      src = src.substr(0, maxWidth - 1) + '…';
+    } else {
+      var halfWidth = Math.round(maxWidth / 2);
+      if (src.length > col + halfWidth) src = src.substr(0, col + halfWidth - 1) + '…';
+      col -= src.length - maxWidth;
+      src = '…' + src.substr(1 - maxWidth);
+    }
+  }
+
+  var errLen = 1;
+  var errEnd = '';
+
+  if (end) {
+    if (end.line === start.line && col + (end.col - start.col) <= maxWidth + 1) {
+      errLen = end.col - start.col;
+    } else {
+      errLen = Math.min(src.length + 1, maxWidth) - col;
+      errEnd = '…';
+    }
+  }
+
+  var offset = col > 1 ? ' '.repeat(col - 1) : '';
+  var err = '^'.repeat(errLen);
+  return "".concat(src, "\n").concat(offset).concat(err).concat(errEnd);
+}

package/browser/dist/errors.js

@@ -1,115 +1,112 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.YAMLWarning = exports.YAMLSyntaxError = exports.YAMLSemanticError = exports.YAMLReferenceError = exports.YAMLError = void 0;
-
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-
-var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
-
-var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
-
-var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
-
-var _wrapNativeSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapNativeSuper"));
-
-var _Node = _interopRequireDefault(require("./cst/Node"));
-
-var YAMLError =
-/*#__PURE__*/
-function (_Error) {
-  (0, _inherits2.default)(YAMLError, _Error);
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+import _wrapNativeSuper from "@babel/runtime/helpers/wrapNativeSuper";
+import Node from './cst/Node';
+import { getLinePos, getPrettyContext } from './cst/source-utils';
+import Range from './cst/Range';
+export var YAMLError = /*#__PURE__*/function (_Error) {
+  _inherits(YAMLError, _Error);
 
   function YAMLError(name, source, message) {
     var _this;
 
-    (0, _classCallCheck2.default)(this, YAMLError);
-    if (!message || !(source instanceof _Node.default)) throw new Error("Invalid arguments for new ".concat(name));
-    _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(YAMLError).call(this));
+    _classCallCheck(this, YAMLError);
+
+    if (!message || !(source instanceof Node)) throw new Error("Invalid arguments for new ".concat(name));
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(YAMLError).call(this));
     _this.name = name;
     _this.message = message;
     _this.source = source;
     return _this;
   }
 
-  (0, _createClass2.default)(YAMLError, [{
+  _createClass(YAMLError, [{
     key: "makePretty",
     value: function makePretty() {
-      if (this.source) {
-        this.nodeType = this.source.type;
+      if (!this.source) return;
+      this.nodeType = this.source.type;
+      var cst = this.source.context && this.source.context.root;
+
+      if (typeof this.offset === 'number') {
+        this.range = new Range(this.offset, this.offset + 1);
+        var start = cst && getLinePos(this.offset, cst);
+
+        if (start) {
+          var end = {
+            line: start.line,
+            col: start.col + 1
+          };
+          this.linePos = {
+            start: start,
+            end: end
+          };
+        }
+
+        delete this.offset;
+      } else {
         this.range = this.source.range;
         this.linePos = this.source.rangeAsLinePos;
-        delete this.source;
       }
+
+      if (this.linePos) {
+        var _this$linePos$start = this.linePos.start,
+            line = _this$linePos$start.line,
+            col = _this$linePos$start.col;
+        this.message += " at line ".concat(line, ", column ").concat(col);
+        var ctx = cst && getPrettyContext(this.linePos, cst);
+        if (ctx) this.message += ":\n\n".concat(ctx, "\n");
+      }
+
+      delete this.source;
     }
   }]);
-  return YAMLError;
-}((0, _wrapNativeSuper2.default)(Error));
 
-exports.YAMLError = YAMLError;
-
-var YAMLReferenceError =
-/*#__PURE__*/
-function (_YAMLError) {
-  (0, _inherits2.default)(YAMLReferenceError, _YAMLError);
+  return YAMLError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+export var YAMLReferenceError = /*#__PURE__*/function (_YAMLError) {
+  _inherits(YAMLReferenceError, _YAMLError);
 
   function YAMLReferenceError(source, message) {
-    (0, _classCallCheck2.default)(this, YAMLReferenceError);
-    return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(YAMLReferenceError).call(this, 'YAMLReferenceError', source, message));
+    _classCallCheck(this, YAMLReferenceError);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(YAMLReferenceError).call(this, 'YAMLReferenceError', source, message));
   }
 
   return YAMLReferenceError;
 }(YAMLError);
-
-exports.YAMLReferenceError = YAMLReferenceError;
-
-var YAMLSemanticError =
-/*#__PURE__*/
-function (_YAMLError2) {
-  (0, _inherits2.default)(YAMLSemanticError, _YAMLError2);
+export var YAMLSemanticError = /*#__PURE__*/function (_YAMLError2) {
+  _inherits(YAMLSemanticError, _YAMLError2);
 
   function YAMLSemanticError(source, message) {
-    (0, _classCallCheck2.default)(this, YAMLSemanticError);
-    return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(YAMLSemanticError).call(this, 'YAMLSemanticError', source, message));
+    _classCallCheck(this, YAMLSemanticError);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(YAMLSemanticError).call(this, 'YAMLSemanticError', source, message));
   }
 
   return YAMLSemanticError;
 }(YAMLError);
-
-exports.YAMLSemanticError = YAMLSemanticError;
-
-var YAMLSyntaxError =
-/*#__PURE__*/
-function (_YAMLError3) {
-  (0, _inherits2.default)(YAMLSyntaxError, _YAMLError3);
+export var YAMLSyntaxError = /*#__PURE__*/function (_YAMLError3) {
+  _inherits(YAMLSyntaxError, _YAMLError3);
 
   function YAMLSyntaxError(source, message) {
-    (0, _classCallCheck2.default)(this, YAMLSyntaxError);
-    return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(YAMLSyntaxError).call(this, 'YAMLSyntaxError', source, message));
+    _classCallCheck(this, YAMLSyntaxError);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(YAMLSyntaxError).call(this, 'YAMLSyntaxError', source, message));
   }
 
   return YAMLSyntaxError;
 }(YAMLError);
-
-exports.YAMLSyntaxError = YAMLSyntaxError;
-
-var YAMLWarning =
-/*#__PURE__*/
-function (_YAMLError4) {
-  (0, _inherits2.default)(YAMLWarning, _YAMLError4);
+export var YAMLWarning = /*#__PURE__*/function (_YAMLError4) {
+  _inherits(YAMLWarning, _YAMLError4);
 
   function YAMLWarning(source, message) {
-    (0, _classCallCheck2.default)(this, YAMLWarning);
-    return (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(YAMLWarning).call(this, 'YAMLWarning', source, message));
+    _classCallCheck(this, YAMLWarning);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(YAMLWarning).call(this, 'YAMLWarning', source, message));
   }
 
   return YAMLWarning;
-}(YAMLError);
-
-exports.YAMLWarning = YAMLWarning;
+}(YAMLError);

package/browser/dist/foldFlowLines.js

@@ -1,19 +1,8 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = foldFlowLines;
-exports.FOLD_QUOTED = exports.FOLD_BLOCK = exports.FOLD_FLOW = void 0;
-var FOLD_FLOW = 'flow';
-exports.FOLD_FLOW = FOLD_FLOW;
-var FOLD_BLOCK = 'block';
-exports.FOLD_BLOCK = FOLD_BLOCK;
-var FOLD_QUOTED = 'quoted'; // presumes i+1 is at the start of a line
+export var FOLD_FLOW = 'flow';
+export var FOLD_BLOCK = 'block';
+export var FOLD_QUOTED = 'quoted'; // presumes i+1 is at the start of a line
 // returns index of last newline in more-indented block
 
-exports.FOLD_QUOTED = FOLD_QUOTED;
-
 var consumeMoreIndentedLines = function consumeMoreIndentedLines(text, i) {
   var ch = text[i + 1];
 
@@ -49,7 +38,7 @@ var consumeMoreIndentedLines = function consumeMoreIndentedLines(text, i) {
  */
 
 
-function foldFlowLines(text, indent, mode, _ref) {
+export default function foldFlowLines(text, indent, mode, _ref) {
   var indentAtStart = _ref.indentAtStart,
       _ref$lineWidth = _ref.lineWidth,
       lineWidth = _ref$lineWidth === void 0 ? 80 : _ref$lineWidth,