diff --git a/dist/Document.js b/dist/Document.js new file mode 100644 index 00000000..1040f039 --- /dev/null +++ b/dist/Document.js @@ -0,0 +1,418 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _addComment = _interopRequireDefault(require("./addComment")); + +var _listTagNames = _interopRequireDefault(require("./listTagNames")); + +var _Node = require("./ast/Node"); + +var _errors = require("./errors"); + +var _schema = _interopRequireWildcard(require("./schema")); + +var _Collection = _interopRequireWildcard(require("./schema/Collection")); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } + +function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +var isCollectionItem = function isCollectionItem(node) { + return node && [_Node.Type.MAP_KEY, _Node.Type.MAP_VALUE, _Node.Type.SEQ_ITEM].includes(node.type); +}; + +var Document = +/*#__PURE__*/ +function () { + function Document(schema) { + _classCallCheck(this, Document); + + this.anchors = {}; + this.commentBefore = null; + this.comment = null; + this.contents = null; + this.errors = []; + this.tagPrefixes = []; + this.schema = schema instanceof _schema.default ? schema : new _schema.default(schema); + this.version = null; + this.warnings = []; + } + + _createClass(Document, [{ + key: "parse", + value: function parse(_ref) { + var _this = this; + + var _ref$directives = _ref.directives, + directives = _ref$directives === void 0 ? [] : _ref$directives, + _ref$contents = _ref.contents, + contents = _ref$contents === void 0 ? [] : _ref$contents, + error = _ref.error; + + if (error) { + if (!error.source) error.source = this; + this.errors.push(error); + } + + var directiveComments = []; + directives.forEach(function (directive) { + var comment = directive.comment, + name = directive.name; + + switch (name) { + case 'TAG': + _this.resolveTagDirective(directive); + + break; + + case 'YAML': + _this.resolveYamlDirective(directive); + + break; + + default: + if (name) _this.warnings.push(new _errors.YAMLWarning(directive, "YAML 1.2 only supports %TAG and %YAML directives, and not %".concat(name))); + } + + if (comment) directiveComments.push(comment); + }); + this.commentBefore = directiveComments.join('\n') || null; + var comments = { + before: [], + after: [] + }; + var contentNodes = []; + contents.forEach(function (node) { + if (node.valueRange && !node.valueRange.isEmpty) { + if (contentNodes.length === 1) { + _this.errors.push(new _errors.YAMLSyntaxError(node, 'Document is not valid YAML (bad indentation?)')); + } + + contentNodes.push(_this.resolveNode(node)); + } else if (node.comment) { + var cc = contentNodes.length === 0 ? comments.before : comments.after; + cc.push(node.comment); + } + }); + + switch (contentNodes.length) { + case 0: + this.contents = null; + comments.after = comments.before; + break; + + case 1: + this.contents = contentNodes[0]; + + if (this.contents) { + var cb = comments.before.join('\n') || null; + + if (cb) { + var cbNode = this.contents instanceof _Collection.default && this.contents.items[0] ? this.contents.items[0] : this.contents; + cbNode.commentBefore = cbNode.commentBefore ? "".concat(cb, "\n").concat(cbNode.commentBefore) : cb; + } + } else { + comments.after = comments.before.concat(comments.after); + } + + break; + + default: + this.contents = contentNodes; + + if (this.contents[0]) { + this.contents[0].commentBefore = comments.before.join('\n') || null; + } else { + comments.after = comments.before.concat(comments.after); + } + + } + + this.comment = comments.after.join('\n') || null; + return this; + } + }, { + key: "resolveTagDirective", + value: function resolveTagDirective(directive) { + var _directive$parameters = _slicedToArray(directive.parameters, 2), + handle = _directive$parameters[0], + prefix = _directive$parameters[1]; + + if (handle && prefix) { + if (this.tagPrefixes.every(function (p) { + return p.handle !== handle; + })) { + this.tagPrefixes.push({ + handle: handle, + prefix: prefix + }); + } else { + this.errors.push(new _errors.YAMLSemanticError(directive, 'The %TAG directive must only be given at most once per handle in the same document.')); + } + } else { + this.errors.push(new _errors.YAMLSemanticError(directive, 'Insufficient parameters given for %TAG directive')); + } + } + }, { + key: "resolveYamlDirective", + value: function resolveYamlDirective(directive) { + var _directive$parameters2 = _slicedToArray(directive.parameters, 1), + version = _directive$parameters2[0]; + + if (this.version) this.errors.push(new _errors.YAMLSemanticError(directive, 'The %YAML directive must only be given at most once per document.')); + if (!version) this.errors.push(new _errors.YAMLSemanticError(directive, 'Insufficient parameters given for %YAML directive'));else if (version !== '1.2') this.warnings.push(new _errors.YAMLWarning(directive, "Document will be parsed as YAML 1.2 rather than YAML ".concat(version))); + this.version = version; + } + }, { + key: "resolveTagName", + value: function resolveTagName(node) { + var tag = node.tag, + type = node.type; + var nonSpecific = false; + + if (tag) { + var handle = tag.handle, + suffix = tag.suffix, + verbatim = tag.verbatim; + + if (verbatim) { + if (verbatim !== '!' && verbatim !== '!!') return verbatim; + this.errors.push(new _errors.YAMLSemanticError(node, "Verbatim tags aren't resolved, so ".concat(verbatim, " is invalid."))); + } else if (handle === '!' && !suffix) { + nonSpecific = true; + } else { + var prefix = this.tagPrefixes.find(function (p) { + return p.handle === handle; + }) || _schema.DefaultTagPrefixes.find(function (p) { + return p.handle === handle; + }); + + if (prefix) { + if (suffix) return prefix.prefix + suffix; + this.errors.push(new _errors.YAMLSemanticError(node, "The ".concat(handle, " tag has no suffix."))); + } else { + this.errors.push(new _errors.YAMLSemanticError(node, "The ".concat(handle, " tag handle is non-default and was not declared."))); + } + } + } + + switch (type) { + case _Node.Type.BLOCK_FOLDED: + case _Node.Type.BLOCK_LITERAL: + case _Node.Type.QUOTE_DOUBLE: + case _Node.Type.QUOTE_SINGLE: + return _schema.DefaultTags.STR; + + case _Node.Type.FLOW_MAP: + case _Node.Type.MAP: + return _schema.DefaultTags.MAP; + + case _Node.Type.FLOW_SEQ: + case _Node.Type.SEQ: + return _schema.DefaultTags.SEQ; + + case _Node.Type.PLAIN: + return nonSpecific ? _schema.DefaultTags.STR : null; + + default: + return null; + } + } + }, { + key: "resolveNode", + value: function resolveNode(node) { + if (!node) return null; + var anchors = this.anchors, + errors = this.errors, + schema = this.schema; + var hasAnchor = false; + var hasTag = false; + var comments = { + before: [], + after: [] + }; + var props = isCollectionItem(node.context.parent) ? node.context.parent.props.concat(node.props) : node.props; + props.forEach(function (_ref2, i) { + var start = _ref2.start, + end = _ref2.end; + + switch (node.context.src[start]) { + case _Node.Char.COMMENT: + if (!node.commentHasRequiredWhitespace(start)) errors.push(new _errors.YAMLSemanticError(node, 'Comments must be separated from other tokens by white space characters')); + var c = node.context.src.slice(start + 1, end); + var header = node.header, + valueRange = node.valueRange; + + if (valueRange && (start > valueRange.start || header && start > header.start)) { + comments.after.push(c); + } else { + comments.before.push(c); + } + + break; + + case _Node.Char.ANCHOR: + if (hasAnchor) errors.push(new _errors.YAMLSemanticError(node, 'A node can have at most one anchor')); + hasAnchor = true; + break; + + case _Node.Char.TAG: + if (hasTag) errors.push(new _errors.YAMLSemanticError(node, 'A node can have at most one tag')); + hasTag = true; + break; + } + }); + if (hasAnchor) anchors[node.anchor] = node; + var res; + + if (node.type === _Node.Type.ALIAS) { + if (hasAnchor || hasTag) errors.push(new _errors.YAMLSemanticError(node, 'An alias node must not specify any properties')); + var src = anchors[node.rawValue]; + + if (!src) { + errors.push(new _errors.YAMLReferenceError(node, "Aliased anchor not found: ".concat(node.rawValue))); + return null; + } + + res = src.resolved; + } else { + var tagName = this.resolveTagName(node); + + if (tagName) { + res = schema.resolveNodeWithFallback(this, node, tagName); + } else { + if (node.type !== _Node.Type.PLAIN) { + errors.push(new _errors.YAMLSyntaxError(node, "Failed to resolve ".concat(node.type, " node here"))); + return null; + } + + try { + res = schema.resolveScalar(node.strValue || ''); + } catch (error) { + if (!error.source) error.source = node; + errors.push(error); + return null; + } + } + } + + if (res) { + var cb = comments.before.join('\n'); + + if (cb) { + res.commentBefore = res.commentBefore ? "".concat(res.commentBefore, "\n").concat(cb) : cb; + } + + var ca = comments.after.join('\n'); + if (ca) res.comment = res.comment ? "".concat(res.comment, "\n").concat(ca) : ca; + } + + return node.resolved = res; + } + }, { + key: "listNonDefaultTags", + value: function listNonDefaultTags() { + var _DefaultTagPrefixes$f = _schema.DefaultTagPrefixes.find(function (p) { + return p.handle === '!!'; + }), + prefix = _DefaultTagPrefixes$f.prefix; + + return (0, _listTagNames.default)(this.contents).filter(function (t) { + return t.indexOf(prefix) !== 0; + }); + } + }, { + key: "setTagPrefix", + value: function setTagPrefix(handle, prefix) { + if (handle[0] !== '!' || handle[handle.length - 1] !== '!') throw new Error('Handle must start and end with !'); + + if (prefix) { + var prev = this.tagPrefixes.find(function (p) { + return p.handle === handle; + }); + if (prev) prev.prefix = prefix;else this.tagPrefixes.push({ + handle: handle, + prefix: prefix + }); + } else { + this.tagPrefixes = this.tagPrefixes.filter(function (p) { + return p.handle !== handle; + }); + } + } + }, { + key: "toJSON", + value: function toJSON() { + return (0, _Collection.toJSON)(this.contents); + } + }, { + key: "toString", + value: function toString() { + if (this.errors.length > 0) throw new Error('Document with errors cannot be stringified'); + var lines = []; + if (this.commentBefore) lines.push(this.commentBefore.replace(/^/gm, '#')); + var hasDirectives = false; + + if (this.version) { + lines.push('%YAML 1.2'); + hasDirectives = true; + } + + var tagNames = this.listNonDefaultTags(); + this.tagPrefixes.forEach(function (_ref3) { + var handle = _ref3.handle, + prefix = _ref3.prefix; + + if (tagNames.some(function (t) { + return t.indexOf(prefix) === 0; + })) { + lines.push("%TAG ".concat(handle, " ").concat(prefix)); + hasDirectives = true; + } + }); + if (hasDirectives) lines.push('---'); + var ctx = { + doc: this, + indent: '' + }; + + if (this.contents) { + if (this.contents.commentBefore) lines.push(this.contents.commentBefore.replace(/^/gm, '#')); // top-level block scalars need to be indented if followed by a comment + + ctx.forceBlockIndent = !!this.comment; + var comment = this.contents.comment; + var body = this.schema.stringify(this.contents, ctx, function () { + comment = null; + }); + lines.push((0, _addComment.default)(body, '', comment)); + } else if (this.contents !== undefined) { + lines.push(this.schema.stringify(this.contents, ctx)); + } + + if (this.comment) lines.push(this.comment.replace(/^/gm, '#')); + return lines.join('\n') + '\n'; + } + }]); + + return Document; +}(); + +exports.default = Document; \ No newline at end of file diff --git a/dist/addComment.js b/dist/addComment.js new file mode 100644 index 00000000..3cac0476 --- /dev/null +++ b/dist/addComment.js @@ -0,0 +1,17 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.addCommentBefore = addCommentBefore; +exports.default = addComment; + +function addCommentBefore(str, indent, comment) { + if (!comment) return str; + var 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 || '', "#")); +} \ No newline at end of file diff --git a/dist/ast/Alias.js b/dist/ast/Alias.js new file mode 100644 index 00000000..9b43f2b9 --- /dev/null +++ b/dist/ast/Alias.js @@ -0,0 +1,69 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _Node2 = _interopRequireDefault(require("./Node")); + +var _Range = _interopRequireDefault(require("./Range")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } _setPrototypeOf(subClass.prototype, superClass && superClass.prototype); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); } + +var Alias = +/*#__PURE__*/ +function (_Node) { + function Alias() { + _classCallCheck(this, Alias); + + return _possibleConstructorReturn(this, _getPrototypeOf(Alias).apply(this, arguments)); + } + + _createClass(Alias, [{ + key: "parse", + + /** + * 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 + */ + value: function parse(context, start) { + this.context = context; + var src = context.src; + + var offset = _Node2.default.endOfIdentifier(src, start + 1); + + this.valueRange = new _Range.default(start + 1, offset); + offset = _Node2.default.endOfWhiteSpace(src, offset); + offset = this.parseComment(offset); + return offset; + } + }]); + + _inherits(Alias, _Node); + + return Alias; +}(_Node2.default); + +exports.default = Alias; \ No newline at end of file diff --git a/dist/ast/BlockValue.js b/dist/ast/BlockValue.js new file mode 100644 index 00000000..59c68162 --- /dev/null +++ b/dist/ast/BlockValue.js @@ -0,0 +1,255 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = exports.Chomp = void 0; + +var _Node2 = _interopRequireWildcard(require("./Node")); + +var _Range = _interopRequireDefault(require("./Range")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } _setPrototypeOf(subClass.prototype, superClass && superClass.prototype); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); } + +var Chomp = { + CLIP: 'CLIP', + KEEP: 'KEEP', + STRIP: 'STRIP' +}; +exports.Chomp = Chomp; + +var BlockValue = +/*#__PURE__*/ +function (_Node) { + function BlockValue(type, props) { + var _this; + + _classCallCheck(this, BlockValue); + + _this = _possibleConstructorReturn(this, _getPrototypeOf(BlockValue).call(this, type, props)); + _this.blockIndent = null; + _this.chomping = Chomp.CLIP; + _this.header = null; + return _this; + } + + _createClass(BlockValue, [{ + key: "parseBlockHeader", + value: function parseBlockHeader(start) { + var src = this.context.src; + var offset = start + 1; + var bi = ''; + + while (true) { + var 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.default(start, offset); + return offset; + } + + offset += 1; + } + } + }, { + key: "parseBlockValue", + value: function parseBlockValue(start) { + var _this$context = this.context, + indent = _this$context.indent, + inFlow = _this$context.inFlow, + src = _this$context.src; + var offset = start; + var bi = this.blockIndent ? indent + this.blockIndent - 1 : indent; + var minBlockIndent = 1; + + for (var ch = src[offset]; ch === '\n'; ch = src[offset]) { + offset += 1; + if (_Node2.default.atDocumentBoundary(src, offset)) break; + + var end = _Node2.default.endOfBlockIndent(src, bi, offset); // should not include tab? + + + if (end === null) break; + + if (!this.blockIndent) { + // no explicit block indent, none yet detected + var lineIndent = end - (offset + indent); + + if (src[end] !== '\n') { + // first line with non-whitespace content + if (lineIndent < minBlockIndent) { + offset -= 1; + break; + } + + this.blockIndent = lineIndent; + bi = indent + this.blockIndent - 1; + } else if (lineIndent > minBlockIndent) { + // empty line with more whitespace + minBlockIndent = lineIndent; + } + } + + offset = _Node2.default.endOfLine(src, end); + } + + this.valueRange = new _Range.default(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 + */ + + }, { + key: "parse", + value: function parse(context, start) { + this.context = context; + var src = context.src; + var offset = this.parseBlockHeader(start); + offset = _Node2.default.endOfWhiteSpace(src, offset); + offset = this.parseComment(offset); + offset = this.parseBlockValue(offset); + return offset; + } + }, { + key: "strValue", + get: function get() { + if (!this.valueRange || !this.context) return null; + var _this$valueRange = this.valueRange, + start = _this$valueRange.start, + end = _this$valueRange.end; + var _this$context2 = this.context, + indent = _this$context2.indent, + src = _this$context2.src; + if (this.valueRange.isEmpty) return ''; + var lastNewLine = null; + var ch = src[end - 1]; + + while (ch === '\n' || ch === '\t' || ch === ' ') { + end -= 1; + + if (end <= start) { + if (this.chomping === Chomp.KEEP) break;else return ''; + } + + if (ch === '\n') lastNewLine = end; + ch = src[end - 1]; + } + + var keepStart = end + 1; + + if (lastNewLine) { + if (this.chomping === Chomp.KEEP) { + keepStart = lastNewLine; + end = this.valueRange.end; + } else { + end = lastNewLine; + } + } + + var bi = indent + this.blockIndent; + var folded = this.type === _Node2.Type.BLOCK_FOLDED; + var str = ''; + var sep = ''; + var prevMoreIndented = false; + + for (var i = start; i < end; ++i) { + for (var j = 0; j < bi; ++j) { + if (src[i] !== ' ') break; + i += 1; + } + + var _ch = src[i]; + + if (_ch === '\n') { + if (sep === '\n') str += '\n';else sep = '\n'; + } else { + var lineEnd = _Node2.default.endOfLine(src, i); + + var line = src.slice(i, lineEnd); + i = lineEnd; + + if (folded && (_ch === ' ' || _ch === '\t') && i < keepStart) { + if (sep === ' ') sep = '\n';else if (!prevMoreIndented && 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; + } + } + } + + return this.chomping === Chomp.STRIP ? str : str + '\n'; + } + }]); + + _inherits(BlockValue, _Node); + + return BlockValue; +}(_Node2.default); + +exports.default = BlockValue; \ No newline at end of file diff --git a/dist/ast/Collection.js b/dist/ast/Collection.js new file mode 100644 index 00000000..25034cdc --- /dev/null +++ b/dist/ast/Collection.js @@ -0,0 +1,207 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _CollectionItem = _interopRequireDefault(require("./CollectionItem")); + +var _Comment = _interopRequireDefault(require("./Comment")); + +var _Node2 = _interopRequireWildcard(require("./Node")); + +var _Range = _interopRequireDefault(require("./Range")); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } _setPrototypeOf(subClass.prototype, superClass && superClass.prototype); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); } + +var Collection = +/*#__PURE__*/ +function (_Node) { + function Collection(firstItem) { + var _this; + + _classCallCheck(this, Collection); + + _this = _possibleConstructorReturn(this, _getPrototypeOf(Collection).call(this, firstItem.type === _Node2.Type.SEQ_ITEM ? _Node2.Type.SEQ : _Node2.Type.MAP)); + _this.items = [firstItem]; + + for (var i = firstItem.props.length - 1; i >= 0; --i) { + if (firstItem.props[i].start < firstItem.context.lineStart) { + // props on previous line are assumed by the collection + _this.props = firstItem.props.slice(0, i + 1); + firstItem.props = firstItem.props.slice(i + 1); + var itemRange = firstItem.props[0] || firstItem.valueRange; + firstItem.range.start = itemRange.start; + break; + } + } + + return _this; + } + /** + * @param {ParseContext} context + * @param {number} start - Index of first character + * @returns {number} - Index of the character after this + */ + + + _createClass(Collection, [{ + key: "parse", + value: function parse(context, start) { + this.context = context; + var parseNode = context.parseNode, + src = context.src; // It's easier to recalculate lineStart here rather than tracking down the + // last context from which to read it -- eemeli/yaml#2 + + var lineStart = _Node2.default.startOfLine(src, start); + + var firstItem = this.items[0]; // First-item context needs to be correct for later comment handling + // -- eemeli/yaml#17 + + firstItem.context.parent = this; + this.valueRange = _Range.default.copy(firstItem.valueRange); + var indent = firstItem.range.start - firstItem.context.lineStart; + var offset = start; + offset = _Node2.default.normalizeOffset(src, offset); + var ch = src[offset]; + var atLineStart = _Node2.default.endOfWhiteSpace(src, lineStart) === offset; + + while (ch) { + while (ch === '\n' || ch === '#') { + if (ch === '#') { + var comment = new _Comment.default(); + offset = comment.parse({ + src: src + }, offset); + this.items.push(comment); + this.valueRange.end = offset; + + if (offset >= src.length) { + ch = null; + break; + } + } + + lineStart = offset + 1; + offset = _Node2.default.endOfIndent(src, lineStart); + + if (_Node2.default.atBlank(src, offset)) { + var wsEnd = _Node2.default.endOfWhiteSpace(src, offset); + + var next = src[wsEnd]; + + if (!next || next === '\n' || next === '#') { + offset = wsEnd; + } + } + + ch = src[offset]; + atLineStart = true; + } + + if (!ch) { + break; + } + + if (offset !== lineStart + indent && (atLineStart || ch !== ':')) { + if (lineStart > start) offset = lineStart; + break; + } + + if (firstItem.type === _Node2.Type.SEQ_ITEM !== (ch === '-')) { + var typeswitch = true; + + if (ch === '-') { + // map key may start with -, as long as it's followed by a non-whitespace char + var _next = src[offset + 1]; + typeswitch = !_next || _next === '\n' || _next === '\t' || _next === ' '; + } + + if (typeswitch) { + if (lineStart > start) offset = lineStart; + break; + } + } + + var node = parseNode({ + atLineStart: atLineStart, + inCollection: true, + indent: indent, + lineStart: lineStart, + parent: this + }, offset); + if (!node) return offset; // at next document start + + this.items.push(node); + this.valueRange.end = node.valueRange.end; + offset = _Node2.default.normalizeOffset(src, node.range.end); + ch = src[offset]; + atLineStart = false; // Need to reset lineStart here if preceding node's range has advanced to + // check the current line's indentation level -- eemeli/yaml#10 + + if (ch && ch !== '\n' && ch !== '#') { + var ls = offset - 1; + var prev = src[ls]; + + while (prev === ' ' || prev === '\t') { + prev = src[--ls]; + } + + if (prev === '\n') lineStart = ls + 1; + } + } + + return offset; + } + }, { + key: "toString", + value: function toString() { + var src = this.context.src, + items = this.items, + range = this.range, + value = this.value; + if (value != null) return value; + var str = src.slice(range.start, items[0].range.start) + String(items[0]); + + for (var i = 1; i < items.length; ++i) { + var item = items[i]; + var _item$context = item.context, + atLineStart = _item$context.atLineStart, + indent = _item$context.indent; + if (atLineStart) for (var _i = 0; _i < indent; ++_i) { + str += ' '; + } + str += String(item); + } + + return _Node2.default.addStringTerminator(src, range.end, str); + } + }]); + + _inherits(Collection, _Node); + + return Collection; +}(_Node2.default); + +exports.default = Collection; \ No newline at end of file diff --git a/dist/ast/CollectionItem.js b/dist/ast/CollectionItem.js new file mode 100644 index 00000000..a2842418 --- /dev/null +++ b/dist/ast/CollectionItem.js @@ -0,0 +1,122 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _errors = require("../errors"); + +var _Node2 = _interopRequireWildcard(require("./Node")); + +var _Range = _interopRequireDefault(require("./Range")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } _setPrototypeOf(subClass.prototype, superClass && superClass.prototype); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); } + +var CollectionItem = +/*#__PURE__*/ +function (_Node) { + function CollectionItem(type, props) { + var _this; + + _classCallCheck(this, CollectionItem); + + _this = _possibleConstructorReturn(this, _getPrototypeOf(CollectionItem).call(this, type, props)); + _this.node = null; + return _this; + } + /** + * @param {ParseContext} context + * @param {number} start - Index of first character + * @returns {number} - Index of the character after this + */ + + + _createClass(CollectionItem, [{ + key: "parse", + value: function parse(context, start) { + this.context = context; + var parseNode = context.parseNode, + src = context.src; + var atLineStart = context.atLineStart, + lineStart = context.lineStart; + if (!atLineStart && this.type === _Node2.Type.SEQ_ITEM) this.error = new _errors.YAMLSemanticError(this, 'Sequence items are not allowed on the same line with map keys'); + var indent = atLineStart ? start - lineStart : context.indent; + + var offset = _Node2.default.endOfWhiteSpace(src, start + 1); + + var ch = src[offset]; + + while (ch === '\n' || ch === '#') { + var next = offset + 1; + + if (ch === '#') { + var _end = _Node2.default.endOfLine(src, next); + + this.props.push(new _Range.default(offset, _end)); + offset = _end; + } else { + atLineStart = true; + lineStart = next; + offset = _Node2.default.endOfWhiteSpace(src, next); // against spec, to match \t allowed after indicator + } + + ch = src[offset]; + } + + if (_Node2.default.nextNodeIsIndented(ch, offset - (lineStart + indent), this.type !== _Node2.Type.SEQ_ITEM)) { + this.node = parseNode({ + atLineStart: atLineStart, + inCollection: false, + indent: indent, + lineStart: lineStart, + parent: this + }, offset); + if (this.node) offset = this.node.range.end; + } else if (lineStart > start + 1) { + offset = lineStart - 1; + } + + var end = this.node ? this.node.valueRange.end : offset; + this.valueRange = new _Range.default(start, end); + return offset; + } + }, { + key: "toString", + value: function toString() { + var src = this.context.src, + node = this.node, + range = this.range, + value = this.value; + if (value != null) return value; + var str = node ? src.slice(range.start, node.range.start) + String(node) : src.slice(range.start, range.end); + return _Node2.default.addStringTerminator(src, range.end, str); + } + }]); + + _inherits(CollectionItem, _Node); + + return CollectionItem; +}(_Node2.default); + +exports.default = CollectionItem; \ No newline at end of file diff --git a/dist/ast/Comment.js b/dist/ast/Comment.js new file mode 100644 index 00000000..2a942ce1 --- /dev/null +++ b/dist/ast/Comment.js @@ -0,0 +1,67 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _Node2 = _interopRequireWildcard(require("./Node")); + +var _Range = _interopRequireDefault(require("./Range")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } _setPrototypeOf(subClass.prototype, superClass && superClass.prototype); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); } + +var Comment = +/*#__PURE__*/ +function (_Node) { + function Comment() { + _classCallCheck(this, Comment); + + return _possibleConstructorReturn(this, _getPrototypeOf(Comment).call(this, _Node2.Type.COMMENT)); + } + /** + * Parses a comment line from the source + * + * @param {ParseContext} context + * @param {number} start - Index of first character + * @returns {number} - Index of the character after this scalar + */ + + + _createClass(Comment, [{ + key: "parse", + value: function parse(context, start) { + this.context = context; + var src = context.src; + var offset = this.parseComment(start); + this.range = new _Range.default(start, offset); + return offset; + } + }]); + + _inherits(Comment, _Node); + + return Comment; +}(_Node2.default); + +exports.default = Comment; \ No newline at end of file diff --git a/dist/ast/Directive.js b/dist/ast/Directive.js new file mode 100644 index 00000000..9e9ff465 --- /dev/null +++ b/dist/ast/Directive.js @@ -0,0 +1,120 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _Node2 = _interopRequireWildcard(require("./Node")); + +var _Range = _interopRequireDefault(require("./Range")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } _setPrototypeOf(subClass.prototype, superClass && superClass.prototype); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +var Directive = +/*#__PURE__*/ +function (_Node) { + _createClass(Directive, null, [{ + key: "endOfDirective", + value: function endOfDirective(src, offset) { + var ch = src[offset]; + + while (ch && ch !== '\n' && ch !== '#') { + ch = src[offset += 1]; + } // last char can't be whitespace + + + ch = src[offset - 1]; + + while (ch === ' ' || ch === '\t') { + offset -= 1; + ch = src[offset - 1]; + } + + return offset; + } + }]); + + function Directive() { + var _this; + + _classCallCheck(this, Directive); + + _this = _possibleConstructorReturn(this, _getPrototypeOf(Directive).call(this, _Node2.Type.DIRECTIVE)); + _this.name = null; + return _this; + } + + _createClass(Directive, [{ + key: "parseName", + value: function parseName(start) { + var src = this.context.src; + var offset = start; + var ch = src[offset]; + + while (ch && ch !== '\n' && ch !== '\t' && ch !== ' ') { + ch = src[offset += 1]; + } + + this.name = src.slice(start, offset); + return offset; + } + }, { + key: "parseParameters", + value: function parseParameters(start) { + var src = this.context.src; + var offset = start; + var ch = src[offset]; + + while (ch && ch !== '\n' && ch !== '#') { + ch = src[offset += 1]; + } + + this.valueRange = new _Range.default(start, offset); + return offset; + } + }, { + key: "parse", + value: function parse(context, start) { + this.context = context; + var src = context.src; + var offset = this.parseName(start + 1); + offset = this.parseParameters(offset); + offset = this.parseComment(offset); + this.range = new _Range.default(start, offset); + return offset; + } + }, { + key: "parameters", + get: function get() { + var raw = this.rawValue; + return raw ? raw.trim().split(/[ \t]+/) : []; + } + }]); + + _inherits(Directive, _Node); + + return Directive; +}(_Node2.default); + +exports.default = Directive; \ No newline at end of file diff --git a/dist/ast/Document.js b/dist/ast/Document.js new file mode 100644 index 00000000..a96cdb30 --- /dev/null +++ b/dist/ast/Document.js @@ -0,0 +1,259 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _errors = require("../errors"); + +var _Comment = _interopRequireDefault(require("./Comment")); + +var _Directive = _interopRequireDefault(require("./Directive")); + +var _Node2 = _interopRequireWildcard(require("./Node")); + +var _Range = _interopRequireDefault(require("./Range")); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } _setPrototypeOf(subClass.prototype, superClass && superClass.prototype); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +var Document = +/*#__PURE__*/ +function (_Node) { + _createClass(Document, null, [{ + key: "startCommentOrEndBlankLine", + value: function startCommentOrEndBlankLine(src, start) { + var offset = _Node2.default.endOfWhiteSpace(src, start); + + var ch = src[offset]; + return ch === '#' || ch === '\n' ? offset : start; + } + }]); + + function Document() { + var _this; + + _classCallCheck(this, Document); + + _this = _possibleConstructorReturn(this, _getPrototypeOf(Document).call(this, _Node2.Type.DOCUMENT)); + _this.directives = null; + _this.contents = null; + return _this; + } + + _createClass(Document, [{ + key: "parseDirectives", + value: function parseDirectives(start) { + var src = this.context.src; + this.directives = []; + var hasDirectives = false; + var offset = start; + + while (!_Node2.default.atDocumentBoundary(src, offset, _Node2.Char.DIRECTIVES_END)) { + offset = Document.startCommentOrEndBlankLine(src, offset); + + switch (src[offset]) { + case '\n': + offset += 1; + break; + + case '#': + { + var comment = new _Comment.default(); + offset = comment.parse({ + src: src + }, offset); + this.directives.push(comment); + } + break; + + case '%': + { + var directive = new _Directive.default(); + offset = directive.parse({ + parent: this, + src: src + }, offset); + this.directives.push(directive); + hasDirectives = true; + } + break; + + default: + if (hasDirectives) { + this.error = new _errors.YAMLSemanticError(this, 'Missing directives-end indicator line'); + } else if (this.directives.length > 0) { + this.contents = this.directives; + this.directives = []; + } + + return offset; + } + } + + if (src[offset]) return offset + 3; + + if (hasDirectives) { + this.error = new _errors.YAMLSemanticError(this, 'Missing directives-end indicator line'); + } else if (this.directives.length > 0) { + this.contents = this.directives; + this.directives = []; + } + + return offset; + } + }, { + key: "parseContents", + value: function parseContents(start) { + var _this$context = this.context, + parseNode = _this$context.parseNode, + src = _this$context.src; + if (!this.contents) this.contents = []; + var lineStart = start; + + while (src[lineStart - 1] === '-') { + lineStart -= 1; + } + + var offset = _Node2.default.endOfWhiteSpace(src, start); + + var atLineStart = lineStart === start; + this.valueRange = new _Range.default(offset); + + while (!_Node2.default.atDocumentBoundary(src, offset, _Node2.Char.DOCUMENT_END)) { + switch (src[offset]) { + case '\n': + offset += 1; + lineStart = offset; + atLineStart = true; + break; + + case '#': + { + var comment = new _Comment.default(); + offset = comment.parse({ + src: src + }, offset); + this.contents.push(comment); + } + break; + + default: + { + var iEnd = _Node2.default.endOfIndent(src, offset); + + var context = { + atLineStart: atLineStart, + indent: -1, + inFlow: false, + inCollection: false, + lineStart: lineStart, + parent: this + }; + var node = parseNode(context, iEnd); + if (!node) return iEnd; // at next document start + + this.contents.push(node); + this.valueRange.end = node.valueRange.end; + offset = node.range.end; + atLineStart = false; + } + } + + offset = Document.startCommentOrEndBlankLine(src, offset); + } + + if (src[offset]) { + offset += 3; + + if (src[offset]) { + offset = _Node2.default.endOfWhiteSpace(src, offset); + + if (src[offset] === '#') { + var _comment = new _Comment.default(); + + offset = _comment.parse({ + src: src + }, offset); + this.contents.push(_comment); + } + + switch (src[offset]) { + case '\n': + offset += 1; + break; + + case undefined: + break; + + default: + this.error = new _errors.YAMLSyntaxError(this, 'Document end marker line cannot have a non-comment suffix'); + } + } + } + + return offset; + } + /** + * @param {ParseContext} context + * @param {number} start - Index of first character + * @returns {number} - Index of the character after this + */ + + }, { + key: "parse", + value: function parse(context, start) { + this.context = context; + var src = context.src; + var offset = src.charCodeAt(start) === 0xfeff ? start + 1 : start; // skip BOM + + offset = this.parseDirectives(offset); + offset = this.parseContents(offset); + return offset; + } + }, { + key: "toString", + value: function toString() { + var contents = this.contents, + src = this.context.src, + directives = this.directives, + value = this.value; + if (value != null) return value; + var str = directives.join(''); + + if (contents.length > 0) { + if (directives.length > 0 || contents[0].type === _Node2.Type.COMMENT) str += '---\n'; + str += contents.join(''); + } + + if (str[str.length - 1] !== '\n') str += '\n'; + return str; + } + }]); + + _inherits(Document, _Node); + + return Document; +}(_Node2.default); + +exports.default = Document; \ No newline at end of file diff --git a/dist/ast/FlowCollection.js b/dist/ast/FlowCollection.js new file mode 100644 index 00000000..8ccafd56 --- /dev/null +++ b/dist/ast/FlowCollection.js @@ -0,0 +1,185 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _errors = require("../errors"); + +var _Comment = _interopRequireDefault(require("./Comment")); + +var _Node2 = _interopRequireWildcard(require("./Node")); + +var _Range = _interopRequireDefault(require("./Range")); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } _setPrototypeOf(subClass.prototype, superClass && superClass.prototype); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); } + +var FlowCollection = +/*#__PURE__*/ +function (_Node) { + function FlowCollection(type, props) { + var _this; + + _classCallCheck(this, FlowCollection); + + _this = _possibleConstructorReturn(this, _getPrototypeOf(FlowCollection).call(this, type, props)); + _this.items = null; + return _this; + } + + _createClass(FlowCollection, [{ + key: "prevNodeIsJsonLike", + value: function prevNodeIsJsonLike() { + var idx = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.items.length; + var node = this.items[idx - 1]; + return !!node && (node.jsonLike || node.type === _Node2.Type.COMMENT && this.nodeIsJsonLike(idx - 1)); + } + /** + * @param {ParseContext} context + * @param {number} start - Index of first character + * @returns {number} - Index of the character after this + */ + + }, { + key: "parse", + value: function parse(context, start) { + this.context = context; + var parseNode = context.parseNode, + src = context.src; + var indent = context.indent, + lineStart = context.lineStart; + var ch = src[start]; // { or [ + + this.items = [ch]; + + var offset = _Node2.default.endOfWhiteSpace(src, start + 1); + + ch = src[offset]; + + while (ch && ch !== ']' && ch !== '}') { + switch (ch) { + case '\n': + { + lineStart = offset + 1; + offset = _Node2.default.endOfIndent(src, lineStart); + if (offset - lineStart <= indent) this.error = new _errors.YAMLSemanticError(this, 'Insufficient indentation in flow collection'); + } + break; + + case ',': + { + this.items.push(ch); + offset += 1; + } + break; + + case '#': + { + var comment = new _Comment.default(); + offset = comment.parse({ + src: src + }, offset); + this.items.push(comment); + } + break; + + case '?': + case ':': + { + var next = src[offset + 1]; + + if (next === '\n' || next === '\t' || next === ' ' || next === ',' || // in-flow : after JSON-like key does not need to be followed by whitespace + ch === ':' && this.prevNodeIsJsonLike()) { + this.items.push(ch); + offset += 1; + break; + } // fallthrough + + } + + default: + { + var node = parseNode({ + atLineStart: false, + inCollection: false, + inFlow: true, + indent: -1, + lineStart: lineStart, + parent: this + }, offset); + + if (!node) { + // at next document start + this.valueRange = new _Range.default(start, offset); + return offset; + } + + this.items.push(node); + offset = _Node2.default.normalizeOffset(src, node.range.end); + } + } + + offset = _Node2.default.endOfWhiteSpace(src, offset); + ch = src[offset]; + } + + this.valueRange = new _Range.default(start, offset + 1); + + if (ch) { + this.items.push(ch); + offset = _Node2.default.endOfWhiteSpace(src, offset + 1); + offset = this.parseComment(offset); + } + + return offset; + } + }, { + key: "toString", + value: function toString() { + var src = this.context.src, + items = this.items, + range = this.range, + value = this.value; + if (value != null) return value; + var nodes = items.filter(function (item) { + return item instanceof _Node2.default; + }); + var str = ''; + var prevEnd = range.start; + nodes.forEach(function (node) { + var prefix = src.slice(prevEnd, node.range.start); + prevEnd = node.range.end; + str += prefix + String(node); + }); + str += src.slice(prevEnd, range.end); + return _Node2.default.addStringTerminator(src, range.end, str); + } + }]); + + _inherits(FlowCollection, _Node); + + return FlowCollection; +}(_Node2.default); + +exports.default = FlowCollection; \ No newline at end of file diff --git a/dist/ast/Node.js b/dist/ast/Node.js new file mode 100644 index 00000000..a39cb07d --- /dev/null +++ b/dist/ast/Node.js @@ -0,0 +1,404 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = exports.Char = exports.Type = void 0; + +var _Range = _interopRequireDefault(require("./Range")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); } + +function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } + +function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } + +function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +var Type = { + ALIAS: 'ALIAS', + 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' +}; +exports.Type = Type; +var Char = { + ANCHOR: '&', + COMMENT: '#', + TAG: '!', + DIRECTIVES_END: '-', + DOCUMENT_END: '.' + /** Root class of all nodes */ + +}; +exports.Char = Char; + +var Node = +/*#__PURE__*/ +function () { + _createClass(Node, null, [{ + key: "addStringTerminator", + value: function addStringTerminator(src, offset, str) { + if (str[str.length - 1] === '\n') return str; + var next = Node.endOfWhiteSpace(src, offset); + return next >= src.length || src[next] === '\n' ? str + '\n' : str; + } // ^(---|...) + + }, { + key: "atDocumentBoundary", + value: function atDocumentBoundary(src, offset, sep) { + var ch0 = src[offset]; + if (!ch0) return true; + var prev = src[offset - 1]; + if (prev && prev !== '\n') return false; + + if (sep) { + if (ch0 !== sep) return false; + } else { + if (ch0 !== Char.DIRECTIVES_END && ch0 !== Char.DOCUMENT_END) return false; + } + + var ch1 = src[offset + 1]; + var ch2 = src[offset + 2]; + if (ch1 !== ch0 || ch2 !== ch0) return false; + var ch3 = src[offset + 3]; + return !ch3 || ch3 === '\n' || ch3 === '\t' || ch3 === ' '; + } + }, { + key: "endOfIdentifier", + value: function endOfIdentifier(src, offset) { + var ch = src[offset]; + var isVerbatim = ch === '<'; + var notOk = isVerbatim ? ['\n', '\t', ' ', '>'] : ['\n', '\t', ' ', '[', ']', '{', '}', ',']; + + while (ch && notOk.indexOf(ch) === -1) { + ch = src[offset += 1]; + } + + if (isVerbatim && ch === '>') offset += 1; + return offset; + } + }, { + key: "endOfIndent", + value: function endOfIndent(src, offset) { + var ch = src[offset]; + + while (ch === ' ') { + ch = src[offset += 1]; + } + + return offset; + } + }, { + key: "endOfLine", + value: function endOfLine(src, offset) { + var ch = src[offset]; + + while (ch && ch !== '\n') { + ch = src[offset += 1]; + } + + return offset; + } + }, { + key: "endOfWhiteSpace", + value: function endOfWhiteSpace(src, offset) { + var ch = src[offset]; + + while (ch === '\t' || ch === ' ') { + ch = src[offset += 1]; + } + + return offset; + } + }, { + key: "startOfLine", + value: function startOfLine(src, offset) { + var ch = src[offset - 1]; + + while (ch && ch !== '\n') { + ch = src[offset -= 1]; + } + + return offset + 1; + } + /** + * End of indentation, or null if the line's indent level is not more + * than `indent` + * + * @param {string} src + * @param {number} indent + * @param {number} lineStart + * @returns {?number} + */ + + }, { + key: "endOfBlockIndent", + value: function endOfBlockIndent(src, indent, lineStart) { + var inEnd = Node.endOfIndent(src, lineStart); + + if (inEnd > lineStart + indent) { + return inEnd; + } else { + var wsEnd = Node.endOfWhiteSpace(src, inEnd); + var ch = src[wsEnd]; + if (!ch || ch === '\n') return wsEnd; + } + + return null; + } + }, { + key: "atBlank", + value: function atBlank(src, offset) { + var ch = src[offset]; + return ch === '\n' || ch === '\t' || ch === ' '; + } + }, { + key: "atCollectionItem", + value: function atCollectionItem(src, offset) { + var ch = src[offset]; + return (ch === '?' || ch === ':' || ch === '-') && Node.atBlank(src, offset + 1); + } + }, { + key: "nextNodeIsIndented", + value: function nextNodeIsIndented(ch, indentDiff, indicatorAsIndent) { + if (!ch || indentDiff < 0) return false; + if (indentDiff > 0) return true; + return indicatorAsIndent && ch === '-'; + } // should be at line or string end, or at next non-whitespace char + + }, { + key: "normalizeOffset", + value: function normalizeOffset(src, offset) { + var ch = src[offset]; + return !ch ? offset : ch !== '\n' && src[offset - 1] === '\n' ? offset - 1 : Node.endOfWhiteSpace(src, offset); + } // fold single newline into space, multiple newlines to N - 1 newlines + // presumes src[offset] === '\n' + + }, { + key: "foldNewline", + value: function foldNewline(src, offset, indent) { + var inCount = 0; + var error = false; + var fold = ''; + var ch = src[offset + 1]; + + while (ch === ' ' || ch === '\t' || ch === '\n') { + switch (ch) { + case '\n': + inCount = 0; + offset += 1; + fold += '\n'; + break; + + case '\t': + if (inCount <= indent) error = true; + offset = Node.endOfWhiteSpace(src, offset + 2) - 1; + break; + + case ' ': + inCount += 1; + offset += 1; + break; + } + + ch = src[offset + 1]; + } + + if (!fold) fold = ' '; + if (ch && inCount <= indent) error = true; + return { + fold: fold, + offset: offset, + error: error + }; + } + }]); + + function Node(type, props, context) { + _classCallCheck(this, Node); + + this.context = context || null; + this.error = null; + this.range = null; + this.valueRange = null; + this.props = props || []; + this.type = type; + this.value = null; + } + + _createClass(Node, [{ + key: "getPropValue", + value: function getPropValue(idx, key, skipKey) { + if (!this.context) return null; + var src = this.context.src; + var prop = this.props[idx]; + return prop && src[prop.start] === key ? src.slice(prop.start + (skipKey ? 1 : 0), prop.end) : null; + } + }, { + key: "commentHasRequiredWhitespace", + value: function commentHasRequiredWhitespace(start) { + var src = this.context.src; + if (this.header && start === this.header.end) return false; + + if (this.valueRange) { + var end = this.valueRange.end; + return start !== end || Node.atBlank(src, end - 1); + } + } + }, { + key: "parseComment", + value: function parseComment(start) { + var src = this.context.src; + + if (src[start] === Char.COMMENT) { + var end = Node.endOfLine(src, start + 1); + var commentRange = new _Range.default(start, end); + this.props.push(commentRange); + return end; + } + + return start; + } + }, { + key: "toString", + value: function toString() { + var src = this.context.src, + range = this.range, + value = this.value; + if (value != null) return value; + var str = src.slice(range.start, range.end); + return Node.addStringTerminator(src, range.end, str); + } + }, { + key: "anchor", + get: function get() { + for (var i = 0; i < this.props.length; ++i) { + var anchor = this.getPropValue(i, Char.ANCHOR, true); + if (anchor != null) return anchor; + } + + return null; + } + }, { + key: "comment", + get: function get() { + var comments = []; + + for (var i = 0; i < this.props.length; ++i) { + var comment = this.getPropValue(i, Char.COMMENT, true); + if (comment != null) comments.push(comment); + } + + return comments.length > 0 ? comments.join('\n') : null; + } + }, { + key: "hasComment", + get: function get() { + if (this.context) { + var src = this.context.src; + + for (var i = 0; i < this.props.length; ++i) { + if (src[this.props[i].start] === Char.COMMENT) return true; + } + } + + return false; + } + }, { + key: "hasProps", + get: function get() { + if (this.context) { + var src = this.context.src; + + for (var i = 0; i < this.props.length; ++i) { + if (src[this.props[i].start] !== Char.COMMENT) return true; + } + } + + return false; + } + }, { + key: "jsonLike", + get: function get() { + var jsonLikeTypes = [Type.FLOW_MAP, Type.FLOW_SEQ, Type.QUOTE_DOUBLE, Type.QUOTE_SINGLE]; + return jsonLikeTypes.indexOf(this.type) !== -1; + } + }, { + key: "rawValue", + get: function get() { + if (!this.valueRange || !this.context) return null; + var _this$valueRange = this.valueRange, + start = _this$valueRange.start, + end = _this$valueRange.end; + return this.context.src.slice(start, end); + } + }, { + key: "tag", + get: function get() { + for (var i = 0; i < this.props.length; ++i) { + var tag = this.getPropValue(i, Char.TAG, false); + + if (tag != null) { + if (tag[1] === '<') { + return { + verbatim: tag.slice(2, -1) + }; + } else { + var _tag$match = tag.match(/^(.*!)([^!]*)$/), + _tag$match2 = _slicedToArray(_tag$match, 3), + _ = _tag$match2[0], + handle = _tag$match2[1], + suffix = _tag$match2[2]; + + return { + handle: handle, + suffix: suffix + }; + } + } + } + + return null; + } + }, { + key: "valueRangeContainsNewline", + get: function get() { + if (!this.valueRange || !this.context) return false; + var _this$valueRange2 = this.valueRange, + start = _this$valueRange2.start, + end = _this$valueRange2.end; + var src = this.context.src; + + for (var i = start; i < end; ++i) { + if (src[i] === '\n') return true; + } + + return false; + } + }]); + + return Node; +}(); + +exports.default = Node; \ No newline at end of file diff --git a/dist/ast/ParseContext.js b/dist/ast/ParseContext.js new file mode 100644 index 00000000..45580252 --- /dev/null +++ b/dist/ast/ParseContext.js @@ -0,0 +1,282 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _errors = require("../errors"); + +var _Alias = _interopRequireDefault(require("./Alias")); + +var _BlockValue = _interopRequireDefault(require("./BlockValue")); + +var _Collection = _interopRequireDefault(require("./Collection")); + +var _CollectionItem = _interopRequireDefault(require("./CollectionItem")); + +var _FlowCollection = _interopRequireDefault(require("./FlowCollection")); + +var _Node = _interopRequireWildcard(require("./Node")); + +var _PlainValue = _interopRequireDefault(require("./PlainValue")); + +var _QuoteDouble = _interopRequireDefault(require("./QuoteDouble")); + +var _QuoteSingle = _interopRequireDefault(require("./QuoteSingle")); + +var _Range = _interopRequireDefault(require("./Range")); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +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; } + +/** + * @param {boolean} atLineStart - Node starts at beginning of line + * @param {boolean} inFlow - true if currently in a flow context + * @param {boolean} inCollection - true if currently in a collection context + * @param {number} indent - Current level of indentation + * @param {number} lineStart - Start of the current line + * @param {Node} parent - The parent of the node + * @param {string} src - Source of the YAML document + */ +var ParseContext = +/*#__PURE__*/ +function () { + _createClass(ParseContext, null, [{ + key: "parseType", + value: function parseType(src, offset, inFlow) { + switch (src[offset]) { + case '*': + return _Node.Type.ALIAS; + + case '>': + return _Node.Type.BLOCK_FOLDED; + + case '|': + return _Node.Type.BLOCK_LITERAL; + + case '{': + return _Node.Type.FLOW_MAP; + + case '[': + return _Node.Type.FLOW_SEQ; + + case '?': + return !inFlow && _Node.default.atBlank(src, offset + 1) ? _Node.Type.MAP_KEY : _Node.Type.PLAIN; + + case ':': + return !inFlow && _Node.default.atBlank(src, offset + 1) ? _Node.Type.MAP_VALUE : _Node.Type.PLAIN; + + case '-': + return !inFlow && _Node.default.atBlank(src, offset + 1) ? _Node.Type.SEQ_ITEM : _Node.Type.PLAIN; + + case '"': + return _Node.Type.QUOTE_DOUBLE; + + case "'": + return _Node.Type.QUOTE_SINGLE; + + default: + return _Node.Type.PLAIN; + } + } + }]); + + function ParseContext() { + var _this = this; + + var orig = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, + atLineStart = _ref.atLineStart, + inCollection = _ref.inCollection, + inFlow = _ref.inFlow, + indent = _ref.indent, + lineStart = _ref.lineStart, + parent = _ref.parent; + + _classCallCheck(this, ParseContext); + + _defineProperty(this, "parseNode", function (overlay, start) { + if (_Node.default.atDocumentBoundary(_this.src, start)) return null; + var context = new ParseContext(_this, overlay); + + var _context$parseProps = context.parseProps(start), + props = _context$parseProps.props, + type = _context$parseProps.type, + valueStart = _context$parseProps.valueStart; + + var node; + + switch (type) { + case _Node.Type.ALIAS: + node = new _Alias.default(type, props); + break; + + case _Node.Type.BLOCK_FOLDED: + case _Node.Type.BLOCK_LITERAL: + node = new _BlockValue.default(type, props); + break; + + case _Node.Type.FLOW_MAP: + case _Node.Type.FLOW_SEQ: + node = new _FlowCollection.default(type, props); + break; + + case _Node.Type.MAP_KEY: + case _Node.Type.MAP_VALUE: + case _Node.Type.SEQ_ITEM: + node = new _CollectionItem.default(type, props); + break; + + case _Node.Type.COMMENT: + case _Node.Type.PLAIN: + node = new _PlainValue.default(type, props); + break; + + case _Node.Type.QUOTE_DOUBLE: + node = new _QuoteDouble.default(type, props); + break; + + case _Node.Type.QUOTE_SINGLE: + node = new _QuoteSingle.default(type, props); + break; + + default: + node.error = new _errors.YAMLSyntaxError(node, "Unknown node type: ".concat(JSON.stringify(type))); + node.range = new _Range.default(start, start + 1); + return node; + } + + var offset = node.parse(context, valueStart); + var nodeEnd = _this.src[offset] === '\n' ? offset + 1 : offset; + + if (nodeEnd <= start) { + node.error = new Error("Node#parse consumed no characters"); + node.error.parseEnd = nodeEnd; + node.error.source = node; + nodeEnd = start + 1; + } + + node.range = new _Range.default(start, nodeEnd); + + if (context.nodeStartsCollection(node)) { + var collection = new _Collection.default(node); + offset = collection.parse(new ParseContext(context), offset); + collection.range = new _Range.default(start, offset); + return collection; + } + + return node; + }); + + this.atLineStart = atLineStart != null ? atLineStart : orig.atLineStart || false; + this.inCollection = inCollection != null ? inCollection : orig.inCollection || false; + this.inFlow = inFlow != null ? inFlow : orig.inFlow || false; + this.indent = indent != null ? indent : orig.indent; + this.lineStart = lineStart != null ? lineStart : orig.lineStart; + this.parent = parent != null ? parent : orig.parent || {}; + this.src = orig.src; + } // for logging + + + _createClass(ParseContext, [{ + key: "nodeStartsCollection", + value: function nodeStartsCollection(node) { + var inCollection = this.inCollection, + inFlow = this.inFlow, + src = this.src; + if (inCollection || inFlow) return false; + if (node instanceof _CollectionItem.default) return true; // check for implicit key + + var offset = node.range.end; + if (src[offset] === '\n' || src[offset - 1] === '\n') return false; + offset = _Node.default.endOfWhiteSpace(src, offset); + return src[offset] === ':'; + } // Anchor and tag are before type, which determines the node implementation + // class; hence this intermediate step. + + }, { + key: "parseProps", + value: function parseProps(offset) { + var inFlow = this.inFlow, + parent = this.parent, + src = this.src; + var props = []; + var lineHasProps = false; + offset = _Node.default.endOfWhiteSpace(src, offset); + var ch = src[offset]; + + while (ch === _Node.Char.ANCHOR || ch === _Node.Char.COMMENT || ch === _Node.Char.TAG || ch === '\n') { + if (ch === '\n') { + var lineStart = offset + 1; + + var inEnd = _Node.default.endOfIndent(src, lineStart); + + var indentDiff = inEnd - (lineStart + this.indent); + var noIndicatorAsIndent = parent.type === _Node.Type.SEQ_ITEM && parent.context.atLineStart; + if (!_Node.default.nextNodeIsIndented(src[inEnd], indentDiff, !noIndicatorAsIndent)) break; + this.atLineStart = true; + this.lineStart = lineStart; + lineHasProps = false; + offset = inEnd; + } else if (ch === _Node.Char.COMMENT) { + var end = _Node.default.endOfLine(src, offset + 1); + + props.push(new _Range.default(offset, end)); + offset = end; + } else { + var _end = _Node.default.endOfIdentifier(src, offset + 1); + + props.push(new _Range.default(offset, _end)); + lineHasProps = true; + offset = _Node.default.endOfWhiteSpace(src, _end); + } + + ch = src[offset]; + } // '- &a : b' has an anchor on an empty node + + + if (lineHasProps && ch === ':' && _Node.default.atBlank(src, offset + 1)) offset -= 1; + var type = ParseContext.parseType(src, offset, inFlow); + return { + props: props, + type: type, + valueStart: offset + }; + } + /** + * Parses a node from the source + * @param {ParseContext} overlay + * @param {number} start - Index of first non-whitespace character for the node + * @returns {?Node} - null if at a document boundary + */ + + }, { + key: "pretty", + get: function get() { + var obj = { + start: "".concat(this.lineStart, " + ").concat(this.indent), + in: [], + parent: this.parent.type + }; + if (!this.atLineStart) obj.start += ' + N'; + if (this.inCollection) obj.in.push('collection'); + if (this.inFlow) obj.in.push('flow'); + return obj; + } + }]); + + return ParseContext; +}(); + +exports.default = ParseContext; \ No newline at end of file diff --git a/dist/ast/PlainValue.js b/dist/ast/PlainValue.js new file mode 100644 index 00000000..2c3acb52 --- /dev/null +++ b/dist/ast/PlainValue.js @@ -0,0 +1,186 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _Node2 = _interopRequireDefault(require("./Node")); + +var _Range = _interopRequireDefault(require("./Range")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } _setPrototypeOf(subClass.prototype, superClass && superClass.prototype); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); } + +var PlainValue = +/*#__PURE__*/ +function (_Node) { + function PlainValue() { + _classCallCheck(this, PlainValue); + + return _possibleConstructorReturn(this, _getPrototypeOf(PlainValue).apply(this, arguments)); + } + + _createClass(PlainValue, [{ + key: "parseBlockValue", + value: function parseBlockValue(start) { + var _this$context = this.context, + indent = _this$context.indent, + inFlow = _this$context.inFlow, + src = _this$context.src; + var offset = start; + + for (var ch = src[offset]; ch === '\n'; ch = src[offset]) { + if (_Node2.default.atDocumentBoundary(src, offset + 1)) break; + + var end = _Node2.default.endOfBlockIndent(src, indent, offset + 1); + + if (end === null || src[end] === '#') break; + offset = PlainValue.endOfLine(src, end, inFlow); + } + + if (this.valueRange.isEmpty) this.valueRange.start = start; + this.valueRange.end = offset; + return offset; + } + /** + * Parses a plain value from the source + * + * Accepted forms are: + * ``` + * #comment + * + * first line + * + * first line #comment + * + * first line + * block + * lines + * + * #comment + * block + * lines + * ``` + * where 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 scalar, may be `\n` + */ + + }, { + key: "parse", + value: function parse(context, start) { + this.context = context; + var inFlow = context.inFlow, + src = context.src; + var offset = start; + var ch = src[offset]; + + if (ch && ch !== '#' && ch !== '\n') { + offset = PlainValue.endOfLine(src, start, inFlow); + } + + this.valueRange = new _Range.default(start, offset); + offset = _Node2.default.endOfWhiteSpace(src, offset); + offset = this.parseComment(offset); + + if (!this.hasComment || this.valueRange.isEmpty) { + offset = this.parseBlockValue(offset); + } + + return offset; + } + }, { + key: "strValue", + get: function get() { + if (!this.valueRange || !this.context) return null; + var _this$valueRange = this.valueRange, + start = _this$valueRange.start, + end = _this$valueRange.end; + var src = this.context.src; + var ch = src[end - 1]; + + while (start < end && (ch === '\n' || ch === '\t' || ch === ' ')) { + ch = src[--end - 1]; + } + + ch = src[start]; + + while (start < end && (ch === '\n' || ch === '\t' || ch === ' ')) { + ch = src[++start]; + } + + var str = ''; + + for (var i = start; i < end; ++i) { + var _ch = src[i]; + + if (_ch === '\n') { + var _Node$foldNewline = _Node2.default.foldNewline(src, i, -1), + fold = _Node$foldNewline.fold, + offset = _Node$foldNewline.offset; + + str += fold; + i = offset; + } else if (_ch === ' ' || _ch === '\t') { + // trim trailing whitespace + var wsStart = i; + var next = src[i + 1]; + + while (i < end && (next === ' ' || next === '\t')) { + i += 1; + next = src[i + 1]; + } + + if (next !== '\n') str += i > wsStart ? src.slice(wsStart, i + 1) : _ch; + } else { + str += _ch; + } + } + + return str; + } + }], [{ + key: "endOfLine", + value: function endOfLine(src, start, inFlow) { + var ch = src[start]; + var offset = start; + + while (ch && ch !== '\n') { + if (inFlow && (ch === '[' || ch === ']' || ch === '{' || ch === '}' || ch === ',')) break; + var next = src[offset + 1]; + if (ch === ':' && (next === '\n' || next === '\t' || next === ' ' || next === ',')) break; + if ((ch === ' ' || ch === '\t') && next === '#') break; + offset += 1; + ch = next; + } + + return offset; + } + }]); + + _inherits(PlainValue, _Node); + + return PlainValue; +}(_Node2.default); + +exports.default = PlainValue; \ No newline at end of file diff --git a/dist/ast/QuoteDouble.js b/dist/ast/QuoteDouble.js new file mode 100644 index 00000000..2cbe58fd --- /dev/null +++ b/dist/ast/QuoteDouble.js @@ -0,0 +1,267 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _errors = require("../errors"); + +var _Node2 = _interopRequireDefault(require("./Node")); + +var _Range = _interopRequireDefault(require("./Range")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } _setPrototypeOf(subClass.prototype, superClass && superClass.prototype); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); } + +var QuoteDouble = +/*#__PURE__*/ +function (_Node) { + function QuoteDouble() { + _classCallCheck(this, QuoteDouble); + + return _possibleConstructorReturn(this, _getPrototypeOf(QuoteDouble).apply(this, arguments)); + } + + _createClass(QuoteDouble, [{ + key: "parseCharCode", + value: function parseCharCode(offset, length, errors) { + var src = this.context.src; + var cc = src.substr(offset, length); + var ok = cc.length === length && /^[0-9a-fA-F]+$/.test(cc); + var code = ok ? parseInt(cc, 16) : NaN; + + if (isNaN(code)) { + errors.push(new _errors.YAMLSyntaxError(this, "Invalid escape sequence ".concat(src.substr(offset - 2, length + 2)))); + return src.substr(offset - 2, length + 2); + } + + return String.fromCodePoint(code); + } + /** + * Parses a "double quoted" value from the source + * + * @param {ParseContext} context + * @param {number} start - Index of first character + * @returns {number} - Index of the character after this scalar + */ + + }, { + key: "parse", + value: function parse(context, start) { + this.context = context; + var src = context.src; + var offset = QuoteDouble.endOfQuote(src, start + 1); + this.valueRange = new _Range.default(start, offset); + offset = _Node2.default.endOfWhiteSpace(src, offset); + offset = this.parseComment(offset); + return offset; + } + }, { + key: "strValue", + + /** + * @returns {string | { str: string, errors: YAMLSyntaxError[] }} + */ + get: function get() { + if (!this.valueRange || !this.context) return null; + var errors = []; + var _this$valueRange = this.valueRange, + start = _this$valueRange.start, + end = _this$valueRange.end; + 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')); // Using String#replace is too painful with escaped newlines preceded by + // escaped backslashes; also, this should be faster. + + 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')); + + var _Node$foldNewline = _Node2.default.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 double-quoted string needs to be sufficiently indented')); + } else if (ch === '\\') { + i += 1; + + switch (src[i]) { + case '0': + str += '\0'; + break; + // null character + + case 'a': + str += '\x07'; + break; + // bell character + + case 'b': + str += '\b'; + break; + // backspace + + case 'e': + str += '\x1b'; + break; + // escape character + + case 'f': + str += '\f'; + break; + // form feed + + case 'n': + str += '\n'; + break; + // line feed + + case 'r': + str += '\r'; + break; + // carriage return + + case 't': + str += '\t'; + break; + // horizontal tab + + case 'v': + str += '\v'; + break; + // vertical tab + + case 'N': + str += "\x85"; + break; + // Unicode next line + + case '_': + str += "\xA0"; + break; + // Unicode non-breaking space + + case 'L': + str += "\u2028"; + break; + // Unicode line separator + + case 'P': + str += "\u2029"; + break; + // Unicode paragraph separator + + case ' ': + str += ' '; + break; + + case '"': + str += '"'; + break; + + case '/': + str += '/'; + break; + + case '\\': + str += '\\'; + break; + + case '\t': + str += '\t'; + break; + + case 'x': + str += this.parseCharCode(i + 1, 2, errors); + i += 2; + break; + + case 'u': + str += this.parseCharCode(i + 1, 4, errors); + i += 4; + break; + + case 'U': + str += this.parseCharCode(i + 1, 8, errors); + i += 8; + break; + + case '\n': + // skip escaped newlines, but still trim the following line + while (src[i + 1] === ' ' || src[i + 1] === '\t') { + i += 1; + } + + break; + + default: + errors.push(new _errors.YAMLSyntaxError(this, "Invalid escape sequence ".concat(src.substr(i - 1, 2)))); + str += '\\' + src[i]; + } + } else if (ch === ' ' || ch === '\t') { + // trim trailing whitespace + var wsStart = i; + var next = src[i + 1]; + + while (next === ' ' || next === '\t') { + i += 1; + next = src[i + 1]; + } + + if (next !== '\n') str += i > wsStart ? src.slice(wsStart, i + 1) : ch; + } else { + str += ch; + } + } + + return errors.length > 0 ? { + errors: errors, + str: str + } : str; + } + }], [{ + key: "endOfQuote", + value: function endOfQuote(src, offset) { + var ch = src[offset]; + + while (ch && ch !== '"') { + offset += ch === '\\' ? 2 : 1; + ch = src[offset]; + } + + return offset + 1; + } + }]); + + _inherits(QuoteDouble, _Node); + + return QuoteDouble; +}(_Node2.default); + +exports.default = QuoteDouble; \ No newline at end of file diff --git a/dist/ast/QuoteSingle.js b/dist/ast/QuoteSingle.js new file mode 100644 index 00000000..75abf2b2 --- /dev/null +++ b/dist/ast/QuoteSingle.js @@ -0,0 +1,142 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _errors = require("../errors"); + +var _Node2 = _interopRequireDefault(require("./Node")); + +var _Range = _interopRequireDefault(require("./Range")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } _setPrototypeOf(subClass.prototype, superClass && superClass.prototype); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); } + +var QuoteSingle = +/*#__PURE__*/ +function (_Node) { + function QuoteSingle() { + _classCallCheck(this, QuoteSingle); + + return _possibleConstructorReturn(this, _getPrototypeOf(QuoteSingle).apply(this, arguments)); + } + + _createClass(QuoteSingle, [{ + key: "parse", + + /** + * Parses a 'single quoted' value from the source + * + * @param {ParseContext} context + * @param {number} start - Index of first character + * @returns {number} - Index of the character after this scalar + */ + value: function parse(context, start) { + 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); + offset = this.parseComment(offset); + return offset; + } + }, { + key: "strValue", + + /** + * @returns {string | { str: string, errors: YAMLSyntaxError[] }} + */ + get: function get() { + if (!this.valueRange || !this.context) return null; + var errors = []; + var _this$valueRange = this.valueRange, + start = _this$valueRange.start, + end = _this$valueRange.end; + 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")); + 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')); + + var _Node$foldNewline = _Node2.default.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')); + } else if (ch === "'") { + str += ch; + i += 1; + if (src[i] !== "'") errors.push(new _errors.YAMLSyntaxError(this, 'Unescaped single quote? This should not happen.')); + } else if (ch === ' ' || ch === '\t') { + // trim trailing whitespace + var wsStart = i; + var next = src[i + 1]; + + while (next === ' ' || next === '\t') { + i += 1; + next = src[i + 1]; + } + + if (next !== '\n') str += i > wsStart ? src.slice(wsStart, i + 1) : ch; + } else { + str += ch; + } + } + + return errors.length > 0 ? { + errors: errors, + str: str + } : str; + } + }], [{ + key: "endOfQuote", + value: function endOfQuote(src, offset) { + var ch = src[offset]; + + while (ch) { + if (ch === "'") { + if (src[offset + 1] !== "'") break; + ch = src[offset += 2]; + } else { + ch = src[offset += 1]; + } + } + + return offset + 1; + } + }]); + + _inherits(QuoteSingle, _Node); + + return QuoteSingle; +}(_Node2.default); + +exports.default = QuoteSingle; \ No newline at end of file diff --git a/dist/ast/Range.js b/dist/ast/Range.js new file mode 100644 index 00000000..d2e1d79d --- /dev/null +++ b/dist/ast/Range.js @@ -0,0 +1,46 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +var Range = +/*#__PURE__*/ +function () { + _createClass(Range, null, [{ + key: "copy", + value: function copy(orig) { + return new Range(orig.start, orig.end); + } + }]); + + function Range(start, end) { + _classCallCheck(this, Range); + + this.start = start; + this.end = end || start; + } + + _createClass(Range, [{ + key: "isEmpty", + get: function get() { + return typeof this.start !== 'number' || !this.end || this.end <= this.start; + } + }, { + key: "length", + get: function get() { + return this.isEmpty ? 0 : this.end - this.start; + } + }]); + + return Range; +}(); + +exports.default = Range; \ No newline at end of file diff --git a/dist/ast/parse.js b/dist/ast/parse.js new file mode 100644 index 00000000..be3b84ee --- /dev/null +++ b/dist/ast/parse.js @@ -0,0 +1,34 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = parse; + +var _Document = _interopRequireDefault(require("./Document")); + +var _ParseContext = _interopRequireDefault(require("./ParseContext")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +// Published as 'yaml/parse-ast' +function parse(src) { + if (src.indexOf('\r') !== -1) src = src.replace(/\r\n?/g, '\n'); + var context = new _ParseContext.default({ + src: src + }); + var documents = []; + var offset = 0; + + while (offset < src.length) { + var doc = new _Document.default(); + offset = doc.parse(context, offset); + documents.push(doc); + } + + documents.toString = function () { + return documents.join('...\n'); + }; + + return documents; +} \ No newline at end of file diff --git a/dist/createNode.js b/dist/createNode.js new file mode 100644 index 00000000..f73896db --- /dev/null +++ b/dist/createNode.js @@ -0,0 +1,40 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = createNode; + +var _Map = _interopRequireDefault(require("./schema/Map")); + +var _Pair = _interopRequireDefault(require("./schema/Pair")); + +var _Scalar = _interopRequireDefault(require("./schema/Scalar")); + +var _Seq = _interopRequireDefault(require("./schema/Seq")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function createNode(value) { + var wrapScalars = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + if (value == null) return new _Scalar.default(null); + if (_typeof(value) !== 'object') return wrapScalars ? new _Scalar.default(value) : value; + + if (Array.isArray(value)) { + var seq = new _Seq.default(); + seq.items = value.map(function (v) { + return createNode(v, wrapScalars); + }); + return seq; + } else { + var map = new _Map.default(); + map.items = Object.keys(value).map(function (key) { + var k = createNode(key, wrapScalars); + var v = createNode(value[key], wrapScalars); + return new _Pair.default(k, v); + }); + return map; + } +} \ No newline at end of file diff --git a/dist/errors.js b/dist/errors.js new file mode 100644 index 00000000..ef864352 --- /dev/null +++ b/dist/errors.js @@ -0,0 +1,132 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.YAMLWarning = exports.YAMLSyntaxError = exports.YAMLSemanticError = exports.YAMLReferenceError = void 0; + +var _Node = _interopRequireDefault(require("./ast/Node")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } _setPrototypeOf(subClass.prototype, superClass && superClass.prototype); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() {} Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, _setPrototypeOf(function Super() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); }, Class)); }; return _wrapNativeSuper(Class); } + +function _construct(Parent, args, Class) { if (typeof Reflect !== "undefined" && Reflect.construct) { _construct = Reflect.construct; } else { _construct = function _construct(Parent, args, Class) { var a = [null]; a.push.apply(a, args); var Constructor = Parent.bind.apply(Parent, a); var instance = new Constructor(); if (Class) _setPrototypeOf(instance, Class.prototype); return instance; }; } return _construct.apply(null, arguments); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); } + +var YAMLReferenceError = +/*#__PURE__*/ +function (_ReferenceError) { + function YAMLReferenceError(source, message) { + var _this; + + _classCallCheck(this, YAMLReferenceError); + + if (!message || !(source instanceof _Node.default)) { + throw new Error('Invalid arguments for new YAMLReferenceError'); + } + + _this = _possibleConstructorReturn(this, _getPrototypeOf(YAMLReferenceError).call(this)); + _this.name = 'YAMLReferenceError'; + _this.message = message; + _this.source = source; + return _this; + } + + _inherits(YAMLReferenceError, _ReferenceError); + + return YAMLReferenceError; +}(_wrapNativeSuper(ReferenceError)); + +exports.YAMLReferenceError = YAMLReferenceError; + +var YAMLSemanticError = +/*#__PURE__*/ +function (_SyntaxError) { + function YAMLSemanticError(source, message) { + var _this2; + + _classCallCheck(this, YAMLSemanticError); + + if (!message || !(source instanceof _Node.default)) { + throw new Error('Invalid arguments for new YAMLSemanticError'); + } + + _this2 = _possibleConstructorReturn(this, _getPrototypeOf(YAMLSemanticError).call(this)); + _this2.name = 'YAMLSemanticError'; + _this2.message = message; + _this2.source = source; + return _this2; + } + + _inherits(YAMLSemanticError, _SyntaxError); + + return YAMLSemanticError; +}(_wrapNativeSuper(SyntaxError)); + +exports.YAMLSemanticError = YAMLSemanticError; + +var YAMLSyntaxError = +/*#__PURE__*/ +function (_SyntaxError2) { + function YAMLSyntaxError(source, message) { + var _this3; + + _classCallCheck(this, YAMLSyntaxError); + + if (!message || !(source instanceof _Node.default)) { + throw new Error('Invalid arguments for new YAMLSyntaxError'); + } + + _this3 = _possibleConstructorReturn(this, _getPrototypeOf(YAMLSyntaxError).call(this)); + _this3.name = 'YAMLSyntaxError'; + _this3.message = message; + _this3.source = source; + return _this3; + } + + _inherits(YAMLSyntaxError, _SyntaxError2); + + return YAMLSyntaxError; +}(_wrapNativeSuper(SyntaxError)); + +exports.YAMLSyntaxError = YAMLSyntaxError; + +var YAMLWarning = +/*#__PURE__*/ +function (_Error) { + function YAMLWarning(source, message) { + var _this4; + + _classCallCheck(this, YAMLWarning); + + if (!message || !(source instanceof _Node.default)) { + throw new Error('Invalid arguments for new YAMLWarning'); + } + + _this4 = _possibleConstructorReturn(this, _getPrototypeOf(YAMLWarning).call(this)); + _this4.name = 'YAMLWarning'; + _this4.message = message; + _this4.source = source; + return _this4; + } + + _inherits(YAMLWarning, _Error); + + return YAMLWarning; +}(_wrapNativeSuper(Error)); + +exports.YAMLWarning = YAMLWarning; \ No newline at end of file diff --git a/dist/foldFlowLines.js b/dist/foldFlowLines.js new file mode 100644 index 00000000..c523c471 --- /dev/null +++ b/dist/foldFlowLines.js @@ -0,0 +1,139 @@ +"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'; +/** + * Tries to keep input at up to `lineWidth` characters, splitting only on spaces + * not followed by newlines or spaces unless `mode` is `'quoted'`. Lines are + * terminated with `\n` and started with `indent`. + * + * @param {string} text + * @param {string} indent + * @param {string} [mode='flow'] `'block'` prevents more-indented lines + * from being folded; `'quoted'` allows for `\` escapes, including escaped + * newlines + * @param {Object} options + * @param {number} [options.indentAtStart] Accounts for leading contents on + * the first line, defaulting to `indent.length` + * @param {number} [options.lineWidth=80] + * @param {number} [options.minContentWidth=20] Allow highly indented lines to + * stretch the line width + * @param {function} options.onFold Called once if the text is folded + * @param {function} options.onFold Called once if any line of text exceeds + * lineWidth characters + */ + +exports.FOLD_QUOTED = FOLD_QUOTED; + +function foldFlowLines(text, indent, mode, _ref) { + var indentAtStart = _ref.indentAtStart, + _ref$lineWidth = _ref.lineWidth, + lineWidth = _ref$lineWidth === void 0 ? 80 : _ref$lineWidth, + _ref$minContentWidth = _ref.minContentWidth, + minContentWidth = _ref$minContentWidth === void 0 ? 20 : _ref$minContentWidth, + onFold = _ref.onFold, + onOverflow = _ref.onOverflow; + if (!lineWidth || lineWidth < 0) return text; + var endStep = Math.max(1 + minContentWidth, 1 + lineWidth - indent.length); + if (text.length <= endStep) return text; + var folds = []; + var escapedFolds = {}; + var end = lineWidth - (typeof indentAtStart === 'number' ? indentAtStart : indent.length); + var split = undefined; + var prev = undefined; + var overflow = false; + + for (var i = 0, ch = text[0]; ch; ch = text[i += 1]) { + if (mode === FOLD_QUOTED && ch === '\\') { + switch (text[i + 1]) { + case 'x': + ch = text[i += 4]; + break; + + case 'u': + ch = text[i += 6]; + break; + + case 'U': + ch = text[i += 10]; + break; + + default: + ch = text[i += 2]; + } + } + + if (ch === '\n') { + if (mode === FOLD_BLOCK) { + // more-indented lines in blocks can't be folded + var next = text[i + 1]; + + while (next === ' ' || next === '\t') { + do { + ch = text[i += 1]; + } while (ch && ch !== '\n'); + + next = text[i + 1]; + } + } + + end = i + endStep; + split = undefined; + } else { + if (ch === ' ' && prev && prev !== ' ' && prev !== '\n' && prev !== '\t') { + // space surrounded by non-space can be replaced with newline + indent + var _next = text[i + 1]; + if (_next && _next !== ' ' && _next !== '\n' && _next !== '\t') split = i; + } + + if (i >= end) { + if (split) { + folds.push(split); + end = split + endStep; + split = undefined; + } else if (mode === FOLD_QUOTED) { + // white-space collected at end may stretch past lineWidth + while (prev === ' ' || prev === '\t') { + prev = ch; + ch = text[i += 1]; + overflow = true; + } // i - 2 accounts for not-dropped last char + newline-escaping \ + + + folds.push(i - 2); + escapedFolds[i - 2] = true; + end = i - 2 + endStep; + split = undefined; + } else { + overflow = true; + } + } + } + + prev = ch; + } + + if (overflow && onOverflow) onOverflow(); + if (folds.length === 0) return text; + if (onFold) onFold(); + var res = text.slice(0, folds[0]); + + for (var _i = 0; _i < folds.length; ++_i) { + var fold = folds[_i]; + + var _end = folds[_i + 1] || text.length; + + if (mode === FOLD_QUOTED && escapedFolds[fold]) res += "".concat(text[fold], "\\"); + res += "\n".concat(indent).concat(text.slice(fold + 1, _end)); + } + + return res; +} \ No newline at end of file diff --git a/dist/index.js b/dist/index.js new file mode 100644 index 00000000..a1da0453 --- /dev/null +++ b/dist/index.js @@ -0,0 +1,99 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _parse = _interopRequireDefault(require("./ast/parse")); + +var _createNode = _interopRequireDefault(require("./createNode")); + +var _Document3 = _interopRequireDefault(require("./Document")); + +var _schema = _interopRequireDefault(require("./schema")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } _setPrototypeOf(subClass.prototype, superClass && superClass.prototype); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); } + +var defaultOptions = { + merge: false, + schema: 'core', + tags: null +}; + +function parseDocuments(src, options) { + var resolvedOptions = options ? Object.assign({}, defaultOptions, options) : defaultOptions; + var schema = new _schema.default(resolvedOptions); + return (0, _parse.default)(src).map(function (astDoc) { + return new _Document3.default(schema).parse(astDoc); + }); +} + +function parse(src, options) { + var docs = parseDocuments(src, options); + docs.forEach(function (doc) { + doc.warnings.forEach(function (warning) { + return console.warn(warning); + }); + doc.errors.forEach(function (error) { + throw error; + }); + }); + + if (docs.length > 1) { + throw new Error('Source contains multiple documents; please use YAML.parseDocuments()'); + } + + return docs[0] && docs[0].toJSON(); +} + +function stringify(value, options) { + var resolvedOptions = options ? Object.assign({}, defaultOptions, options) : defaultOptions; + var doc = new _Document3.default(resolvedOptions); + doc.contents = value; + return String(doc); +} + +var _default = { + createNode: _createNode.default, + defaultOptions: defaultOptions, + Document: + /*#__PURE__*/ + function (_Document2) { + function Document(schema) { + var _this; + + _classCallCheck(this, Document); + + if (schema instanceof _schema.default) { + _this = _possibleConstructorReturn(this, _getPrototypeOf(Document).call(this, schema)); + } else { + _this = _possibleConstructorReturn(this, _getPrototypeOf(Document).call(this, Object.assign({}, defaultOptions, schema))); + } + + return _possibleConstructorReturn(_this); + } + + _inherits(Document, _Document2); + + return Document; + }(_Document3.default), + parse: parse, + parseDocuments: parseDocuments, + stringify: stringify +}; +exports.default = _default; \ No newline at end of file diff --git a/dist/listTagNames.js b/dist/listTagNames.js new file mode 100644 index 00000000..25df8c68 --- /dev/null +++ b/dist/listTagNames.js @@ -0,0 +1,42 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _Collection = _interopRequireDefault(require("./schema/Collection")); + +var _Pair = _interopRequireDefault(require("./schema/Pair")); + +var _Scalar = _interopRequireDefault(require("./schema/Scalar")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +var visit = function visit(node, tags) { + if (node && _typeof(node) === 'object') { + var tag = node.origTag || node.tag; + + if (node instanceof _Collection.default) { + if (tag) tags[tag] = true; + node.items.forEach(function (n) { + return visit(n, tags); + }); + } else if (node instanceof _Pair.default) { + visit(node.key, tags); + visit(node.value, tags); + } else if (node instanceof _Scalar.default) { + if (tag) tags[tag] = true; + } + } + + return tags; +}; + +var _default = function _default(node) { + return Object.keys(visit(node, {})); +}; + +exports.default = _default; \ No newline at end of file diff --git a/dist/resolveValue.js b/dist/resolveValue.js new file mode 100644 index 00000000..e3209599 --- /dev/null +++ b/dist/resolveValue.js @@ -0,0 +1,39 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = resolveValue; + +var _Map = _interopRequireDefault(require("./schema/Map")); + +var _Pair = _interopRequireDefault(require("./schema/Pair")); + +var _Scalar = _interopRequireDefault(require("./schema/Scalar")); + +var _Seq = _interopRequireDefault(require("./schema/Seq")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function resolveValue(doc, value, wrapScalars) { + if (value == null) return new _Scalar.default(null); + if (_typeof(value) !== 'object') return wrapScalars ? new _Scalar.default(value) : value; + + if (Array.isArray(value)) { + var seq = new _Seq.default(doc); + seq.items = value.map(function (v) { + return resolveValue(doc, v, wrapScalars); + }); + return seq; + } else { + var map = new _Map.default(doc); + map.items = Object.keys(value).map(function (key) { + var k = resolveValue(doc, key, wrapScalars); + var v = resolveValue(doc, value[key], wrapScalars); + return new _Pair.default(k, v); + }); + return map; + } +} \ No newline at end of file diff --git a/dist/schema/Collection.js b/dist/schema/Collection.js new file mode 100644 index 00000000..366fb8a1 --- /dev/null +++ b/dist/schema/Collection.js @@ -0,0 +1,149 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = exports.toJSON = void 0; + +var _addComment = _interopRequireDefault(require("../addComment")); + +var _Node2 = _interopRequireDefault(require("./Node")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } _setPrototypeOf(subClass.prototype, superClass && superClass.prototype); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +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; } + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +var toJSON = function toJSON(value) { + return Array.isArray(value) ? value.map(toJSON) : value && _typeof(value) === 'object' && 'toJSON' in value ? value.toJSON() : value; +}; + +exports.toJSON = toJSON; + +var Collection = +/*#__PURE__*/ +function (_Node) { + function Collection() { + var _getPrototypeOf2; + + var _temp, _this; + + _classCallCheck(this, Collection); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + return _possibleConstructorReturn(_this, (_temp = _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(Collection)).call.apply(_getPrototypeOf2, [this].concat(args))), _defineProperty(_assertThisInitialized(_assertThisInitialized(_this)), "items", []), _temp)); + } + + _createClass(Collection, [{ + key: "toJSON", + // overridden in implementations + value: function toJSON() { + return null; + } + }, { + key: "toString", + value: function toString(_ref, onComment) { + var _this2 = this; + + var blockItem = _ref.blockItem, + doc = _ref.doc, + flowChars = _ref.flowChars, + indent = _ref.indent, + inFlow = _ref.inFlow, + itemIndent = _ref.itemIndent; + if (!doc) return JSON.stringify(this); + var ctx = { + doc: doc, + indent: itemIndent, + inFlow: inFlow, + type: null + }; + var hasItemWithComment = false; + var hasItemWithNewLine = false; + var nodes = this.items.reduce(function (nodes, item, i) { + var commentBefore = item && item.commentBefore; + + if (commentBefore) { + hasItemWithComment = true; + commentBefore.match(/^.*$/gm).forEach(function (line) { + nodes.push({ + type: 'comment', + str: "#".concat(line) + }); + }); + } + + var comment = item && item.comment; + if (comment) hasItemWithComment = true; + var str = doc.schema.stringify(item, ctx, function () { + comment = null; + }); + if (!hasItemWithNewLine && str.indexOf('\n') !== -1) hasItemWithNewLine = true; + if (inFlow && i < _this2.items.length - 1) str += ','; + str = (0, _addComment.default)(str, ctx.indent, comment); + nodes.push({ + type: 'item', + str: str + }); + return nodes; + }, []); + var str; + + if (nodes.length === 0) { + str = flowChars.start + flowChars.end; + } else if (inFlow) { + var start = flowChars.start, + end = flowChars.end; + var strings = nodes.map(function (_ref2) { + var str = _ref2.str; + return str; + }); + + if (hasItemWithComment || hasItemWithNewLine || strings.reduce(function (sum, str) { + return sum + str.length + 2; + }, 2) > Collection.maxFlowStringSingleLineLength) { + str = "".concat(start, "\n ").concat(indent).concat(strings.join("\n ".concat(indent)), "\n").concat(indent).concat(end); + } else { + str = "".concat(start, " ").concat(strings.join(' '), " ").concat(end); + } + } else { + str = nodes.map(blockItem).join("\n".concat(indent)); + } + + if (this.comment) { + if (!hasItemWithNewLine && str.indexOf('\n') === -1) str = (0, _addComment.default)(str, indent, this.comment);else str += '\n' + this.comment.replace(/^/gm, "".concat(indent, "#")); + if (onComment) onComment(); + } + + return str; + } + }]); + + _inherits(Collection, _Node); + + return Collection; +}(_Node2.default); + +exports.default = Collection; + +_defineProperty(Collection, "maxFlowStringSingleLineLength", 60); \ No newline at end of file diff --git a/dist/schema/Map.js b/dist/schema/Map.js new file mode 100644 index 00000000..f249119b --- /dev/null +++ b/dist/schema/Map.js @@ -0,0 +1,86 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _Collection2 = _interopRequireWildcard(require("./Collection")); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } _setPrototypeOf(subClass.prototype, superClass && superClass.prototype); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); } + +function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); } + +var YAMLMap = +/*#__PURE__*/ +function (_Collection) { + function YAMLMap() { + _classCallCheck(this, YAMLMap); + + return _possibleConstructorReturn(this, _getPrototypeOf(YAMLMap).apply(this, arguments)); + } + + _createClass(YAMLMap, [{ + key: "toJSON", + value: function toJSON() { + return this.items.reduce(function (map, _ref) { + var stringKey = _ref.stringKey, + value = _ref.value; + map[stringKey] = (0, _Collection2.toJSON)(value); + return map; + }, {}); + } + }, { + key: "toString", + value: function toString() { + var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, + doc = _ref2.doc, + _ref2$indent = _ref2.indent, + indent = _ref2$indent === void 0 ? '' : _ref2$indent, + _ref2$inFlow = _ref2.inFlow, + inFlow = _ref2$inFlow === void 0 ? false : _ref2$inFlow; + + var onComment = arguments.length > 1 ? arguments[1] : undefined; + return _get(_getPrototypeOf(YAMLMap.prototype), "toString", this).call(this, { + blockItem: function blockItem(_ref3) { + var str = _ref3.str; + return str; + }, + doc: doc, + flowChars: { + start: '{', + end: '}' + }, + indent: indent, + inFlow: inFlow, + itemIndent: indent + (inFlow ? ' ' : '') + }, onComment); + } + }]); + + _inherits(YAMLMap, _Collection); + + return YAMLMap; +}(_Collection2.default); + +exports.default = YAMLMap; \ No newline at end of file diff --git a/dist/schema/Node.js b/dist/schema/Node.js new file mode 100644 index 00000000..c4216d6d --- /dev/null +++ b/dist/schema/Node.js @@ -0,0 +1,18 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +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; } + +var Node = function Node() { + _classCallCheck(this, Node); + + _defineProperty(_defineProperty(_defineProperty(_defineProperty(this, "anchor", null), "comment", null), "commentBefore", null), "tag", null); +}; + +exports.default = Node; \ No newline at end of file diff --git a/dist/schema/Pair.js b/dist/schema/Pair.js new file mode 100644 index 00000000..e9425d5c --- /dev/null +++ b/dist/schema/Pair.js @@ -0,0 +1,111 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _addComment = _interopRequireDefault(require("../addComment")); + +var _Collection = _interopRequireWildcard(require("./Collection")); + +var _Scalar = _interopRequireDefault(require("./Scalar")); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +var Pair = +/*#__PURE__*/ +function () { + function Pair(key) { + var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null; + + _classCallCheck(this, Pair); + + this.key = key; + this.value = value; + } + + _createClass(Pair, [{ + key: "toJSON", + value: function toJSON() { + var pair = {}; + pair[this.stringKey] = (0, _Collection.toJSON)(this.value); + return pair; + } + }, { + key: "toString", + value: function toString(ctx, onComment) { + if (!ctx || !ctx.doc) return JSON.stringify(this); + var key = this.key, + value = this.value; + var explicitKey = !key || key.comment || key instanceof _Collection.default; + var _ctx = ctx, + doc = _ctx.doc, + indent = _ctx.indent; + ctx = Object.assign({}, ctx, { + implicitKey: !explicitKey, + indent: indent + ' ' + }); + var keyComment = key && key.comment; + var keyStr = doc.schema.stringify(key, ctx, function () { + keyComment = null; + }); + if (keyComment) keyStr = (0, _addComment.default)(keyStr, ctx.indent, keyComment); + ctx.implicitKey = false; + var valueStr = doc.schema.stringify(value, ctx, onComment); + var vcb = value && value.commentBefore ? " #".concat(value.commentBefore.replace(/\n+(?!\n|$)/g, "$&".concat(ctx.indent, "#"))) : ''; + + if (explicitKey) { + return "? ".concat(keyStr, "\n").concat(indent, ":").concat(vcb ? "".concat(vcb, "\n").concat(ctx.indent) : ' ').concat(valueStr); + } else if (value instanceof _Collection.default) { + return "".concat(keyStr, ":").concat(vcb, "\n").concat(ctx.indent).concat(valueStr); + } else { + return "".concat(keyStr, ":").concat(vcb ? "".concat(vcb, "\n").concat(ctx.indent) : ' ').concat(valueStr); + } + } + }, { + key: "commentBefore", + get: function get() { + return this.key && this.key.commentBefore; + }, + set: function set(cb) { + if (this.key == null) this.key = new _Scalar.default(null); + this.key.commentBefore = cb; + } + }, { + key: "comment", + get: function get() { + return this.value && this.value.comment; + }, + set: function set(comment) { + if (this.value == null) this.value = new _Scalar.default(null); + this.value.comment = comment; + } + }, { + key: "stringKey", + get: function get() { + var key = (0, _Collection.toJSON)(this.key); + if (key === null) return ''; + if (_typeof(key) === 'object') try { + return JSON.stringify(key); + } catch (e) { + /* should not happen, but let's ignore in any case */ + } + return String(key); + } + }]); + + return Pair; +}(); + +exports.default = Pair; \ No newline at end of file diff --git a/dist/schema/Scalar.js b/dist/schema/Scalar.js new file mode 100644 index 00000000..453d2665 --- /dev/null +++ b/dist/schema/Scalar.js @@ -0,0 +1,62 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _Collection = require("./Collection"); + +var _Node2 = _interopRequireDefault(require("./Node")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } _setPrototypeOf(subClass.prototype, superClass && superClass.prototype); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); } + +var Scalar = +/*#__PURE__*/ +function (_Node) { + function Scalar(value) { + var _this; + + _classCallCheck(this, Scalar); + + _this = _possibleConstructorReturn(this, _getPrototypeOf(Scalar).call(this)); + _this.value = value; + return _this; + } + + _createClass(Scalar, [{ + key: "toJSON", + value: function toJSON() { + return (0, _Collection.toJSON)(this.value); + } + }, { + key: "toString", + value: function toString() { + return String(this.value); + } + }]); + + _inherits(Scalar, _Node); + + return Scalar; +}(_Node2.default); + +exports.default = Scalar; \ No newline at end of file diff --git a/dist/schema/Seq.js b/dist/schema/Seq.js new file mode 100644 index 00000000..7435f7f4 --- /dev/null +++ b/dist/schema/Seq.js @@ -0,0 +1,82 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _Collection2 = _interopRequireWildcard(require("./Collection")); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } _setPrototypeOf(subClass.prototype, superClass && superClass.prototype); if (superClass) _setPrototypeOf(subClass, superClass); } + +function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); } + +function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; } + +function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); } + +function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; } + +function _getPrototypeOf(o) { _getPrototypeOf = Object.getPrototypeOf || function _getPrototypeOf(o) { return o.__proto__; }; return _getPrototypeOf(o); } + +var YAMLSeq = +/*#__PURE__*/ +function (_Collection) { + function YAMLSeq() { + _classCallCheck(this, YAMLSeq); + + return _possibleConstructorReturn(this, _getPrototypeOf(YAMLSeq).apply(this, arguments)); + } + + _createClass(YAMLSeq, [{ + key: "toJSON", + value: function toJSON() { + return this.items.map(_Collection2.toJSON); + } + }, { + key: "toString", + value: function toString() { + var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, + doc = _ref.doc, + _ref$indent = _ref.indent, + indent = _ref$indent === void 0 ? '' : _ref$indent, + _ref$inFlow = _ref.inFlow, + inFlow = _ref$inFlow === void 0 ? false : _ref$inFlow; + + var onComment = arguments.length > 1 ? arguments[1] : undefined; + return _get(_getPrototypeOf(YAMLSeq.prototype), "toString", this).call(this, { + blockItem: function blockItem(_ref2) { + var type = _ref2.type, + str = _ref2.str; + return type === 'comment' ? str : "- ".concat(str); + }, + doc: doc, + flowChars: { + start: '[', + end: ']' + }, + indent: indent, + inFlow: inFlow, + itemIndent: indent + (inFlow ? ' ' : ' ') + }, onComment); + } + }]); + + _inherits(YAMLSeq, _Collection); + + return YAMLSeq; +}(_Collection2.default); + +exports.default = YAMLSeq; \ No newline at end of file diff --git a/dist/schema/_binary.js b/dist/schema/_binary.js new file mode 100644 index 00000000..595db33c --- /dev/null +++ b/dist/schema/_binary.js @@ -0,0 +1,79 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = exports.binary = void 0; + +var _errors = require("../errors"); + +var _string = require("./_string"); + +// Published as 'yaml/types/binary' +var binary = { + class: Uint8Array, + // Buffer inherits from Uint8Array + 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: function resolve(doc, node) { + if (typeof Buffer === 'function') { + var str = (0, _string.resolve)(doc, node); + return Buffer.from(str, 'base64'); + } else if (typeof atob === 'function') { + var _str = atob((0, _string.resolve)(doc, node)); + + var buffer = new Uint8Array(_str.length); + + for (var i = 0; i < _str.length; ++i) { + buffer[i] = _str.charCodeAt(i); + } + + return buffer; + } else { + doc.errors.push(new _errors.YAMLReferenceError(node, 'This environment does not support reading binary tags; either Buffer or atob is required')); + return null; + } + }, + options: { + lineWidth: 76 + }, + stringify: function stringify(_ref) { + var value = _ref.value; + var str; + + if (typeof Buffer === 'function') { + str = value instanceof Buffer ? value.toString('base64') : Buffer.from(value.buffer).toString('base64'); + } else if (typeof btoa === 'function') { + var s = ''; + + for (var i = 0; i < value.length; ++i) { + s += String.fromCharCode(buf[i]); + } + + str = btoa(s); + } else { + throw new Error('This environment does not support writing binary tags; either Buffer or btoa is required'); + } + + var lineWidth = binary.options.lineWidth; + var n = Math.ceil(str.length / lineWidth); + var lines = new Array(n); + + for (var _i = 0, o = 0; _i < n; ++_i, o += lineWidth) { + lines[_i] = str.substr(o, lineWidth); + } + + return lines.join('\n'); + } +}; +exports.binary = binary; +var _default = [binary]; +exports.default = _default; \ No newline at end of file diff --git a/dist/schema/_string.js b/dist/schema/_string.js new file mode 100644 index 00000000..8a00087f --- /dev/null +++ b/dist/schema/_string.js @@ -0,0 +1,302 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = exports.str = exports.resolve = exports.strOptions = void 0; + +var _addComment = require("../addComment"); + +var _Node = require("../ast/Node"); + +var _foldFlowLines = _interopRequireWildcard(require("../foldFlowLines")); + +function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } } + +var strOptions = { + defaultType: _Node.Type.PLAIN, + dropCR: false, + doubleQuoted: { + jsonEncoding: false, + minMultiLineLength: 40 + }, + fold: { + lineWidth: 80, + minContentWidth: 20 + } +}; +exports.strOptions = strOptions; + +var resolve = function resolve(doc, node) { + // on error, will return { str: string, errors: Error[] } + var res = node.strValue; + if (!res) return ''; + if (typeof res === 'string') return res; + res.errors.forEach(function (error) { + if (!error.source) error.source = node; + doc.errors.push(error); + }); + return res.str; +}; + +exports.resolve = resolve; + +function doubleQuotedString(value, indent, oneLine) { + var _strOptions$doubleQuo = strOptions.doubleQuoted, + jsonEncoding = _strOptions$doubleQuo.jsonEncoding, + minMultiLineLength = _strOptions$doubleQuo.minMultiLineLength; + var json = JSON.stringify(value); + if (jsonEncoding) return json; + var str = ''; + var start = 0; + + for (var i = 0, ch = json[i]; ch; ch = json[++i]) { + if (ch === ' ' && json[i + 1] === '\\' && json[i + 2] === 'n') { + // space before newline needs to be escaped to not be folded + str += json.slice(start, i) + '\\ '; + i += 1; + start = i; + ch = '\\'; + } + + if (ch === '\\') switch (json[i + 1]) { + case 'u': + str += json.slice(start, i); + var code = json.substr(i + 2, 4); + + switch (code) { + case '0000': + str += '\\0'; + break; + + case '0007': + str += '\\a'; + break; + + case '000b': + str += '\\v'; + break; + + case '001b': + str += '\\e'; + break; + + case '0085': + str += '\\N'; + break; + + case '00a0': + str += '\\_'; + break; + + case '2028': + str += '\\L'; + break; + + case '2029': + str += '\\P'; + break; + + default: + if (code.substr(0, 2) === '00') str += '\\x' + code.substr(2);else str += json.substr(i, 6); + } + + i += 5; + start = i + 1; + break; + + case 'n': + if (oneLine || json[i + 2] === '"' || json.length < minMultiLineLength) { + i += 1; + } else { + // folding will eat first newline + str += json.slice(start, i) + '\n\n'; + + while (json[i + 2] === '\\' && json[i + 3] === 'n' && json[i + 4] !== '"') { + str += '\n'; + i += 2; + } + + str += indent; // space after newline needs to be escaped to not be folded + + if (json[i + 2] === ' ') str += '\\'; + i += 1; + start = i + 1; + } + + break; + + default: + i += 1; + } + } + + str = start ? str + json.slice(start) : json; + return oneLine ? str : (0, _foldFlowLines.default)(str, indent, _foldFlowLines.FOLD_QUOTED, strOptions.fold); +} + +function singleQuotedString(value, indent, oneLine) { + if (oneLine) { + if (/\n/.test(value)) return doubleQuotedString(value, indent, true); + } else { + // single quoted string can't have leading or trailing whitespace around newline + if (/[ \t]\n|\n[ \t]/.test(value)) return doubleQuotedString(value, indent, false); + } + + value = "'" + value.replace(/'/g, "''").replace(/\n+/g, "$&\n".concat(indent)) + "'"; + return oneLine ? value : (0, _foldFlowLines.default)(value, indent, _foldFlowLines.FOLD_FLOW, strOptions.fold); +} + +function blockString(value, indent, literal, forceBlockIndent, comment, onComment) { + // block can't end in whitespace unless the last line is non-empty + if (/\n[\t ]+$/.test(value)) return doubleQuotedString(value, indent, false); + if (forceBlockIndent && !indent) indent = ' '; + var indentSize = indent ? '2' : '1'; // root is at -1 + + var header = literal ? '|' : '>'; + if (!value) return header + '\n'; + var wsStart = ''; + var wsEnd = ''; + value = value.replace(/[\n\t ]*$/, function (ws) { + var n = ws.indexOf('\n'); + + if (n === -1) { + header += '-'; // strip + } else if (value === ws || n !== ws.length - 1) { + header += '+'; // keep + } + + wsEnd = ws.replace(/\n$/, ''); + return ''; + }).replace(/^[\n ]*/, function (ws) { + if (ws.indexOf(' ') !== -1) header += indentSize; + var m = ws.match(/ +$/); + + if (m) { + wsStart = ws.slice(0, -m[0].length); + return m[0]; + } else { + wsStart = ws; + return ''; + } + }); + if (wsEnd) wsEnd = wsEnd.replace(/\n+(?!\n|$)/g, "$&".concat(indent)); + if (wsStart) wsStart = wsStart.replace(/\n+/g, "$&".concat(indent)); + + if (comment) { + header += ' #' + comment.replace(/ ?[\r\n]+/g, ' '); + if (onComment) onComment(); + } + + if (!value) return "".concat(header).concat(indentSize, "\n").concat(indent).concat(wsEnd); + + if (literal) { + value = value.replace(/\n+/g, "$&".concat(indent)); + return "".concat(header, "\n").concat(indent).concat(wsStart).concat(value).concat(wsEnd); + } + + value = value.replace(/\n+/g, '\n$&').replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, '$1$2') // more-indented lines aren't folded + // ^ ind.line ^ empty ^ capture next empty lines only at end of indent + .replace(/\n+/g, "$&".concat(indent)); + var body = (0, _foldFlowLines.default)("".concat(wsStart).concat(value).concat(wsEnd), indent, _foldFlowLines.FOLD_BLOCK, strOptions.fold); + return "".concat(header, "\n").concat(indent).concat(body); +} + +function plainString(value, indent, implicitKey, inFlow, forceBlockIndent, tags, comment, onComment) { + if (implicitKey && /[\n[\]{},]/.test(value) || inFlow && /[[\]{},]/.test(value)) { + return doubleQuotedString(value, indent, implicitKey); + } + + if (!value || /^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t ]$/.test(value)) { + // not allowed: + // - empty string + // - start with an indicator character (except [?:-]) or /[?-] / + // - '\n ', ': ' or ' \n' anywhere + // - '#' not preceded by a non-space char + // - end with ' ' + return implicitKey || inFlow ? doubleQuotedString(value, indent, implicitKey) : blockString(value, indent, false, forceBlockIndent, comment, onComment); + } // Need to verify that output will be parsed as a string + + + var str = value.replace(/\n+/g, "$&\n".concat(indent)); + + if (typeof tags.resolveScalar(str).value !== 'string') { + return doubleQuotedString(value, indent, implicitKey); + } + + var body = implicitKey ? str : (0, _foldFlowLines.default)(str, indent, _foldFlowLines.FOLD_FLOW, strOptions.fold); + + if (comment && !inFlow && (body.indexOf('\n') !== -1 || comment.indexOf('\n') !== -1)) { + if (onComment) onComment(); + return (0, _addComment.addCommentBefore)(body, indent, comment); + } + + return body; +} + +var str = { + class: String, + tag: 'tag:yaml.org,2002:str', + resolve: resolve, + options: strOptions, + stringify: function stringify(_ref) { + var comment = _ref.comment, + value = _ref.value; + + var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, + forceBlockIndent = _ref2.forceBlockIndent, + implicitKey = _ref2.implicitKey, + indent = _ref2.indent, + inFlow = _ref2.inFlow, + tags = _ref2.tags, + type = _ref2.type; + + var onComment = arguments.length > 2 ? arguments[2] : undefined; + var dropCR = strOptions.dropCR, + defaultType = strOptions.defaultType; + if (typeof value !== 'string') value = String(value); + if (dropCR && /\r/.test(value)) value = value.replace(/\r\n?/g, '\n'); + + var _stringify = function _stringify(_type) { + switch (_type) { + case _Node.Type.BLOCK_FOLDED: + return blockString(value, indent, false, forceBlockIndent, comment, onComment); + + case _Node.Type.BLOCK_LITERAL: + return blockString(value, indent, true, forceBlockIndent, comment, onComment); + + case _Node.Type.QUOTE_DOUBLE: + return doubleQuotedString(value, indent, implicitKey, comment); + + case _Node.Type.QUOTE_SINGLE: + return singleQuotedString(value, indent, implicitKey, comment); + + case _Node.Type.PLAIN: + return plainString(value, indent, implicitKey, inFlow, forceBlockIndent, tags, comment, onComment); + + default: + return null; + } + }; + + if (type !== _Node.Type.QUOTE_DOUBLE && /[\x00-\x08\x0b-\x1f\x7f-\x9f]/.test(value)) { + // force double quotes on control characters + type = _Node.Type.QUOTE_DOUBLE; + } else if (inFlow && (type === _Node.Type.BLOCK_FOLDED || type === _Node.Type.BLOCK_LITERAL)) { + // should not happen; blocks are not valid inside flow containers + type = _Node.Type.QUOTE_DOUBLE; + } + + var res = _stringify(type); + + if (res === null) { + res = _stringify(defaultType); + if (res === null) throw new Error("Unsupported default string type ".concat(defaultType)); + } + + return res; + } +}; +exports.str = str; +var _default = [str]; +exports.default = _default; \ No newline at end of file diff --git a/dist/schema/_timestamp.js b/dist/schema/_timestamp.js new file mode 100644 index 00000000..f9c9e3ae --- /dev/null +++ b/dist/schema/_timestamp.js @@ -0,0 +1,100 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = exports.timestamp = exports.floatTime = exports.intTime = void 0; + +var _core = require("./core"); + +// Published as 'yaml/types/timestamp' +var parseSexagesimal = function parseSexagesimal(sign, parts) { + var n = parts.split(':').reduce(function (n, p) { + return n * 60 + Number(p); + }, 0); + return sign === '-' ? -n : n; +}; // hhhh:mm:ss.sss + + +var stringifySexagesimal = function stringifySexagesimal(_ref) { + var value = _ref.value; + if (!isNan(value) || !isFinite(value)) return (0, _core.stringifyNumber)(value); + var sign = ''; + + if (value < 0) { + sign = '-'; + value = Math.abs(value); + } + + var parts = [value % 60]; // seconds, including ms + + if (value < 60) { + parts.unshift(0); // at least one : is required + } else { + value = Math.round((value - parts[0]) / 60); + parts.unshift(value % 60); // minutes + + if (value >= 60) { + value = Math.round((value - parts[0]) / 60); + parts.unshift(value); // hours + } + } + + return sign + parts.map(function (n) { + return n < 10 ? '0' + String(n) : String(n); + }).join(':'); +}; + +var intTime = { + class: Number, + tag: 'tag:yaml.org,2002:int', + format: 'time', + test: /^([-+]?)([0-9][0-9_]*(?::[0-5]?[0-9])+)$/, + resolve: function resolve(str, sign, parts) { + return parseSexagesimal(sign, parts.replace(/_/g, '')); + }, + stringify: stringifySexagesimal +}; +exports.intTime = intTime; +var floatTime = { + class: Number, + tag: 'tag:yaml.org,2002:float', + format: 'time', + test: /^([-+]?)([0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*)$/, + resolve: function resolve(str, sign, parts) { + return parseSexagesimal(sign, parts.replace(/_/g, '')); + }, + stringify: stringifySexagesimal +}; +exports.floatTime = floatTime; +var timestamp = { + class: Date, + tag: 'tag:yaml.org,2002:timestamp', + // If the time zone is omitted, the timestamp is assumed to be specified in UTC. The time part + // may be omitted altogether, resulting in a date format. In such a case, the time part is + // assumed to be 00:00:00Z (start of day, UTC). + test: RegExp('^(?:' + '([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})' + // YYYY-Mm-Dd + '(?:(?:t|T|[ \\t]+)' + // t | T | whitespace + '([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\.[0-9]+)?)' + // Hh:Mm:Ss(.ss)? + '(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?' + // Z | +5 | -03:30 + ')?' + ')$'), + resolve: function resolve(str, year, month, day, hour, minute, second, millisec, tz) { + if (millisec) millisec = (millisec + '00').substr(1, 3); + var date = Date.UTC(year, month - 1, day, hour || 0, minute || 0, second || 0, millisec || 0); + + if (tz && tz !== 'Z') { + var d = parseSexagesimal(tz[0], tz.slice(1)); + if (Math.abs(d) < 30) d *= 60; + date -= 60000 * d; + } + + return new Date(date); + }, + stringify: function stringify(_ref2) { + var value = _ref2.value; + return value.toISOString(); + } +}; +exports.timestamp = timestamp; +var _default = [intTime, floatTime, timestamp]; +exports.default = _default; \ No newline at end of file diff --git a/dist/schema/core.js b/dist/schema/core.js new file mode 100644 index 00000000..f26b8e35 --- /dev/null +++ b/dist/schema/core.js @@ -0,0 +1,91 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = exports.nullOptions = exports.stringifyNumber = void 0; + +var _failsafe = _interopRequireDefault(require("./failsafe")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var stringifyNumber = function stringifyNumber(_ref) { + var value = _ref.value; + return isFinite(value) ? JSON.stringify(value) : isNaN(value) ? '.nan' : value < 0 ? '-.inf' : '.inf'; +}; + +exports.stringifyNumber = stringifyNumber; +var nullOptions = { + nullStr: 'null' +}; +exports.nullOptions = nullOptions; + +var _default = _failsafe.default.concat([{ + class: null, + tag: 'tag:yaml.org,2002:null', + test: /^(?:~|null)?$/i, + resolve: function resolve() { + return null; + }, + options: nullOptions, + stringify: function stringify() { + return nullOptions.nullStr; + } +}, { + class: Boolean, + tag: 'tag:yaml.org,2002:bool', + test: /^(?:true|false)$/i, + resolve: function resolve(str) { + return str[0] === 't' || str[0] === 'T'; + } +}, { + class: Number, + tag: 'tag:yaml.org,2002:int', + format: 'oct', + test: /^0o([0-7]+)$/, + resolve: function resolve(str, oct) { + return parseInt(oct, 8); + }, + stringify: function stringify(_ref2) { + var value = _ref2.value; + return '0o' + value.toString(8); + } +}, { + class: Number, + tag: 'tag:yaml.org,2002:int', + test: /^[-+]?[0-9]+$/, + resolve: function resolve(str) { + return parseInt(str, 10); + }, + stringify: stringifyNumber +}, { + class: Number, + tag: 'tag:yaml.org,2002:int', + format: 'hex', + test: /^0x([0-9a-fA-F]+)$/, + resolve: function resolve(str, hex) { + return parseInt(hex, 16); + }, + stringify: function stringify(_ref3) { + var value = _ref3.value; + return '0x' + value.toString(16); + } +}, { + class: Number, + tag: 'tag:yaml.org,2002:float', + test: /^(?:[-+]?\.inf|(\.nan))$/i, + resolve: function resolve(str, nan) { + return nan ? NaN : str[0] === '-' ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY; + }, + stringify: stringifyNumber +}, { + class: Number, + tag: 'tag:yaml.org,2002:float', + test: /^[-+]?(0|[1-9][0-9]*)(\.[0-9]*)?([eE][-+]?[0-9]+)?$/, + resolve: function resolve(str) { + return parseFloat(str); + }, + stringify: stringifyNumber +}]); + +exports.default = _default; \ No newline at end of file diff --git a/dist/schema/extended.js b/dist/schema/extended.js new file mode 100644 index 00000000..cc2f7f85 --- /dev/null +++ b/dist/schema/extended.js @@ -0,0 +1,127 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = exports.boolOptions = exports.nullOptions = void 0; + +var _errors = require("../errors"); + +var _binary = _interopRequireDefault(require("./_binary")); + +var _timestamp = _interopRequireDefault(require("./_timestamp")); + +var _core = require("./core"); + +var _failsafe = _interopRequireDefault(require("./failsafe")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var nullOptions = { + nullStr: 'null' +}; +exports.nullOptions = nullOptions; +var boolOptions = { + trueStr: 'true', + falseStr: 'false' +}; +exports.boolOptions = boolOptions; + +var _default = _failsafe.default.concat([{ + class: null, + tag: 'tag:yaml.org,2002:null', + test: /^(?:~|null)?$/i, + resolve: function resolve() { + return null; + }, + options: nullOptions, + stringify: function stringify() { + return nullOptions.nullStr; + } +}, { + class: Boolean, + tag: 'tag:yaml.org,2002:bool', + test: /^(?:y|yes|true|on)$/i, + resolve: function resolve() { + return true; + }, + options: boolOptions, + stringify: function stringify(_ref) { + var value = _ref.value; + return value ? boolOptions.trueStr : boolOptions.falseStr; + } +}, { + class: Boolean, + tag: 'tag:yaml.org,2002:bool', + test: /^(?:n|no|false|off)$/i, + resolve: function resolve() { + return false; + }, + options: boolOptions, + stringify: function stringify(_ref2) { + var value = _ref2.value; + return value ? boolOptions.trueStr : boolOptions.falseStr; + } +}, { + class: Number, + tag: 'tag:yaml.org,2002:int', + format: 'bin', + test: /^0b([0-1_]+)$/, + resolve: function resolve(str, bin) { + return parseInt(bin.replace(/_/g, ''), 2); + }, + stringify: function stringify(_ref3) { + var value = _ref3.value; + return '0b' + value.toString(2); + } +}, { + class: Number, + tag: 'tag:yaml.org,2002:int', + format: 'oct', + test: /^[-+]?0([0-7_]+)$/, + resolve: function resolve(str, oct) { + return parseInt(oct.replace(/_/g, ''), 8); + }, + stringify: function stringify(_ref4) { + var value = _ref4.value; + return (value < 0 ? '-0' : '0') + value.toString(8); + } +}, { + class: Number, + tag: 'tag:yaml.org,2002:int', + test: /^[-+]?[0-9][0-9_]*$/, + resolve: function resolve(str) { + return parseInt(str.replace(/_/g, ''), 10); + }, + stringify: _core.stringifyNumber +}, { + class: Number, + tag: 'tag:yaml.org,2002:int', + format: 'hex', + test: /^0x([0-9a-fA-F_]+)$/, + resolve: function resolve(str, hex) { + return parseInt(hex.replace(/_/g, ''), 16); + }, + stringify: function stringify(_ref5) { + var value = _ref5.value; + return (value < 0 ? '-0x' : '0x') + value.toString(16); + } +}, { + class: Number, + tag: 'tag:yaml.org,2002:float', + test: /^(?:[-+]?\.inf|(\.nan))$/i, + resolve: function resolve(str, nan) { + return nan ? NaN : str[0] === '-' ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY; + }, + stringify: _core.stringifyNumber +}, { + class: Number, + tag: 'tag:yaml.org,2002:float', + test: /^[-+]?([0-9][0-9_]*)?\.[0-9_]*([eE][-+]?[0-9]+)?$/, + resolve: function resolve(str) { + return parseFloat(str.replace(/_/g, '')); + }, + stringify: _core.stringifyNumber +}], _timestamp.default, _binary.default); + +exports.default = _default; \ No newline at end of file diff --git a/dist/schema/failsafe.js b/dist/schema/failsafe.js new file mode 100644 index 00000000..788a5ca1 --- /dev/null +++ b/dist/schema/failsafe.js @@ -0,0 +1,39 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = exports.seq = exports.map = void 0; + +var _Map = _interopRequireDefault(require("./Map")); + +var _Seq = _interopRequireDefault(require("./Seq")); + +var _string = require("./_string"); + +var _parseMap = _interopRequireDefault(require("./parseMap")); + +var _parseSeq = _interopRequireDefault(require("./parseSeq")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +var map = { + class: _Map.default, + tag: 'tag:yaml.org,2002:map', + resolve: _parseMap.default, + stringify: function stringify(value, ctx, onComment) { + return value.toString(ctx, onComment); + } +}; +exports.map = map; +var seq = { + class: _Seq.default, + tag: 'tag:yaml.org,2002:seq', + resolve: _parseSeq.default, + stringify: function stringify(value, ctx, onComment) { + return value.toString(ctx, onComment); + } +}; +exports.seq = seq; +var _default = [map, seq, _string.str]; +exports.default = _default; \ No newline at end of file diff --git a/dist/schema/index.js b/dist/schema/index.js new file mode 100644 index 00000000..df4a27e7 --- /dev/null +++ b/dist/schema/index.js @@ -0,0 +1,260 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = exports.DefaultTags = exports.DefaultTagPrefixes = exports.availableSchema = void 0; + +var _Node = require("../ast/Node"); + +var _createNode = _interopRequireDefault(require("../createNode")); + +var _errors = require("../errors"); + +var _Collection = _interopRequireDefault(require("./Collection")); + +var _core = _interopRequireDefault(require("./core")); + +var _extended = _interopRequireDefault(require("./extended")); + +var _failsafe = _interopRequireDefault(require("./failsafe")); + +var _json = _interopRequireDefault(require("./json")); + +var _Pair = _interopRequireDefault(require("./Pair")); + +var _Scalar = _interopRequireDefault(require("./Scalar")); + +var _string = require("./_string"); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +var availableSchema = { + core: _core.default, + extended: _extended.default, + failsafe: _failsafe.default, + json: _json.default +}; +exports.availableSchema = availableSchema; +var defaultPrefix = 'tag:yaml.org,2002:'; +var DefaultTagPrefixes = [{ + handle: '!', + prefix: '!' +}, { + handle: '!!', + prefix: defaultPrefix +}]; +exports.DefaultTagPrefixes = DefaultTagPrefixes; +var DefaultTags = { + MAP: 'tag:yaml.org,2002:map', + SEQ: 'tag:yaml.org,2002:seq', + STR: 'tag:yaml.org,2002:str' +}; +exports.DefaultTags = DefaultTags; + +var isMap = function isMap(_ref) { + var type = _ref.type; + return type === _Node.Type.FLOW_MAP || type === _Node.Type.MAP; +}; + +var isSeq = function isSeq(_ref2) { + var type = _ref2.type; + return type === _Node.Type.FLOW_SEQ || type === _Node.Type.SEQ; +}; + +var Schema = +/*#__PURE__*/ +function () { + _createClass(Schema, null, [{ + key: "defaultStringifier", + value: function defaultStringifier(value) { + return JSON.stringify(value); + } + }]); + + function Schema(_ref3) { + var merge = _ref3.merge, + schema = _ref3.schema, + tags = _ref3.tags; + + _classCallCheck(this, Schema); + + this.merge = !!merge; + this.schema = Array.isArray(schema) ? schema : availableSchema[schema]; + + if (!this.schema) { + var keys = Object.keys(availableSchema).map(function (key) { + return JSON.stringify(key); + }).join(', '); + throw new Error("Unknown schema; use ".concat(keys, ", or { tag, test, resolve }[]")); + } + + if (Array.isArray(tags)) { + this.schema = this.schema.concat(tags); + } else if (typeof tags === 'function') { + this.schema = tags(this.schema.slice()); + } + } // falls back to string on no match + + + _createClass(Schema, [{ + key: "resolveScalar", + value: function resolveScalar(str, tags) { + if (!tags) tags = this.schema; + + for (var i = 0; i < tags.length; ++i) { + var _tags$i = tags[i], + test = _tags$i.test, + resolve = _tags$i.resolve; + + if (test) { + var match = str.match(test); + if (match) return new _Scalar.default(resolve.apply(null, match)); + } + } + + if (this.schema.scalarFallback) str = this.schema.scalarFallback(str); + return new _Scalar.default(str); + } // sets node.resolved on success + + }, { + key: "resolveNode", + value: function resolveNode(doc, node, tagName) { + var tags = this.schema.filter(function (_ref4) { + var tag = _ref4.tag; + return tag === tagName; + }); + var generic = tags.find(function (_ref5) { + var test = _ref5.test; + return !test; + }); + if (node.error) doc.errors.push(node.error); + + try { + if (generic) { + var res = generic.resolve(doc, node); + if (!(res instanceof _Collection.default)) res = new _Scalar.default(res); + node.resolved = res; + } else { + var str = (0, _string.resolve)(doc, node); + + if (typeof str === 'string' && tags.length > 0) { + node.resolved = this.resolveScalar(str, tags); + } + } + } catch (error) { + if (!error.source) error.source = node; + doc.errors.push(error); + node.resolved = null; + } + + if (!node.resolved) return null; + if (node.hasProps) node.resolved.anchor = node.anchor; + if (tagName) node.resolved.tag = tagName; + return node.resolved; + } + }, { + key: "resolveNodeWithFallback", + value: function resolveNodeWithFallback(doc, node, tagName) { + var res = this.resolveNode(doc, node, tagName); + if (node.hasOwnProperty('resolved')) return res; + var fallback = isMap(node) ? DefaultTags.MAP : isSeq(node) ? DefaultTags.SEQ : DefaultTags.STR; + + if (fallback) { + doc.warnings.push(new _errors.YAMLWarning(node, "The tag ".concat(tagName, " is unavailable, falling back to ").concat(fallback))); + + var _res = this.resolveNode(doc, node, fallback); + + _res.origTag = tagName; + return _res; + } else { + doc.errors.push(new _errors.YAMLReferenceError(node, "The tag ".concat(tagName, " is unavailable"))); + } + + return null; + } + }, { + key: "stringify", + value: function stringify(item, ctx, onComment) { + if (!(item instanceof _Scalar.default || item instanceof _Collection.default || item instanceof _Pair.default)) { + item = (0, _createNode.default)(item, true); + } + + ctx.tags = this; + var match; + + if (item instanceof _Pair.default) { + return item.toString(ctx, onComment); + } else if (item.tag) { + match = this.schema.filter(function (_ref6) { + var format = _ref6.format, + tag = _ref6.tag; + return tag === item.tag && (!item.format || format === item.format); + }); + if (match.length === 0) throw new Error("Tag not available: ".concat(item.tag).concat(item.format ? ', format ' + item.format : '')); + } else if (item.value === null) { + match = this.schema.filter(function (t) { + return t.class === null && !t.format; + }); + if (match.length === 0) throw new Error('Schema is missing a null stringifier'); + } else { + var obj = item; + + if (item.hasOwnProperty('value')) { + switch (_typeof(item.value)) { + case 'boolean': + obj = new Boolean(); + break; + + case 'number': + obj = new Number(); + break; + + case 'string': + obj = new String(); + break; + + default: + obj = item.value; + } + } + + match = this.schema.filter(function (t) { + return t.class && obj instanceof t.class && !t.format; + }); + if (match.length === 0) throw new Error("Tag not resolved for ".concat(obj && obj.constructor ? obj.constructor.name : _typeof(obj))); + } + + var stringify = match[0].stringify || Schema.defaultStringifier; + var str = stringify(item, ctx, onComment); + var tag = item.origTag || item.tag; + + if (tag && tag.indexOf(defaultPrefix) !== 0) { + var p = ctx.doc.tagPrefixes.find(function (p) { + return tag.indexOf(p.prefix) === 0; + }); + var tagProp = p ? p.handle + tag.substr(p.prefix.length) : tag[0] === '!' ? tag : "!<".concat(tag, ">"); + + if (item instanceof _Collection.default && !ctx.inFlow && item.items.length > 0) { + return "".concat(tagProp, "\n").concat(ctx.indent).concat(str); + } else { + return "".concat(tagProp, " ").concat(str); + } + } + + return str; + } + }]); + + return Schema; +}(); + +exports.default = Schema; \ No newline at end of file diff --git a/dist/schema/json.js b/dist/schema/json.js new file mode 100644 index 00000000..125c652e --- /dev/null +++ b/dist/schema/json.js @@ -0,0 +1,58 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = void 0; + +var _failsafe = require("./failsafe"); + +var _string = require("./_string"); + +var schema = [_failsafe.map, _failsafe.seq, { + class: String, + tag: 'tag:yaml.org,2002:str', + resolve: _string.resolve +}, { + class: null, + tag: 'tag:yaml.org,2002:null', + test: /^null$/, + resolve: function resolve() { + return null; + } +}, { + class: Boolean, + tag: 'tag:yaml.org,2002:bool', + test: /^true$/, + resolve: function resolve() { + return true; + } +}, { + class: Boolean, + tag: 'tag:yaml.org,2002:bool', + test: /^false$/, + resolve: function resolve() { + return false; + } +}, { + class: Number, + tag: 'tag:yaml.org,2002:int', + test: /^-?(?:0|[1-9][0-9]*)$/, + resolve: function resolve(str) { + return parseInt(str, 10); + } +}, { + class: Number, + tag: 'tag:yaml.org,2002:float', + test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/, + resolve: function resolve(str) { + return parseFloat(str); + } +}]; + +schema.scalarFallback = function (str) { + throw new SyntaxError("Unresolved plain scalar ".concat(JSON.stringify(str))); +}; + +var _default = schema; +exports.default = _default; \ No newline at end of file diff --git a/dist/schema/parseMap.js b/dist/schema/parseMap.js new file mode 100644 index 00000000..3965fe82 --- /dev/null +++ b/dist/schema/parseMap.js @@ -0,0 +1,206 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = parseMap; + +var _Node = require("../ast/Node"); + +var _errors = require("../errors"); + +var _Map = _interopRequireDefault(require("./Map")); + +var _Pair = _interopRequireDefault(require("./Pair")); + +var _parseUtils = require("./parseUtils"); + +var _Seq = _interopRequireDefault(require("./Seq")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); } + +function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); } + +function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); } + +function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } } + +function parseMap(doc, ast) { + var _ref = ast.type === _Node.Type.FLOW_MAP ? resolveFlowMapItems(doc, ast) : resolveBlockMapItems(doc, ast), + comments = _ref.comments, + items = _ref.items; + + var map = new _Map.default(); + map.items = items; + (0, _parseUtils.resolveComments)(map, comments); + + for (var i = 0; i < items.length; ++i) { + var iKey = items[i].key; + + for (var j = i + 1; j < items.length; ++j) { + var jKey = items[j].key; + + if (iKey === jKey || iKey && jKey && iKey.hasOwnProperty('value') && iKey.value === jKey.value) { + doc.errors.push(new _errors.YAMLSemanticError(ast, "Map keys must be unique; \"".concat(iKey, "\" is repeated"))); + break; + } + } + + if (doc.schema.merge && iKey.value === '<<') { + var src = items[i].value; + var srcItems = src instanceof _Seq.default ? src.items.reduce(function (acc, _ref2) { + var items = _ref2.items; + return acc.concat(items); + }, []) : src.items; + var toAdd = srcItems.reduce(function (toAdd, pair) { + var exists = items.some(function (_ref3) { + var key = _ref3.key; + return key.value === pair.key.value; + }) || toAdd.some(function (_ref4) { + var key = _ref4.key; + return key.value === pair.key.value; + }); + return exists ? toAdd : toAdd.concat(pair); + }, []); + Array.prototype.splice.apply(items, [i, 1].concat(_toConsumableArray(toAdd))); + i += toAdd.length - 1; + } + } + + ast.resolved = map; + return map; +} + +function resolveBlockMapItems(doc, ast) { + var comments = []; + var items = []; + var key = undefined; + var keyStart = null; + + for (var i = 0; i < ast.items.length; ++i) { + var item = ast.items[i]; + + switch (item.type) { + case _Node.Type.COMMENT: + comments.push({ + comment: item.comment, + before: items.length + }); + break; + + case _Node.Type.MAP_KEY: + if (key !== undefined) items.push(new _Pair.default(key)); + if (item.error) doc.errors.push(item.error); + key = doc.resolveNode(item.node); + keyStart = null; + break; + + case _Node.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 === _Node.Type.MAP && !item.node.context.atLineStart) { + doc.errors.push(new _errors.YAMLSemanticError(item.node, 'Nested mappings are not allowed in compact mappings')); + } + + items.push(new _Pair.default(key, doc.resolveNode(item.node))); + (0, _parseUtils.checkKeyLength)(doc.errors, ast, i, key, keyStart); + key = undefined; + keyStart = null; + break; + + default: + if (key !== undefined) items.push(new _Pair.default(key)); + key = doc.resolveNode(item); + keyStart = item.range.start; + var nextItem = ast.items[i + 1]; + if (!nextItem || nextItem.type !== _Node.Type.MAP_VALUE) doc.errors.push(new _errors.YAMLSemanticError(item, 'Implicit map keys need to be followed by map values')); + if (item.valueRangeContainsNewline) doc.errors.push(new _errors.YAMLSemanticError(item, 'Implicit map keys need to be on a single line')); + } + } + + if (key !== undefined) items.push(new _Pair.default(key)); + return { + comments: comments, + items: items + }; +} + +function resolveFlowMapItems(doc, ast) { + var comments = []; + var items = []; + var key = undefined; + var keyStart = null; + var explicitKey = false; + var next = '{'; + + for (var i = 0; i < ast.items.length; ++i) { + (0, _parseUtils.checkKeyLength)(doc.errors, ast, i, key, keyStart); + var item = ast.items[i]; + + if (typeof item === 'string') { + if (item === '?' && key === undefined && !explicitKey) { + explicitKey = true; + next = ':'; + continue; + } + + if (item === ':') { + if (key === undefined) key = null; + + if (next === ':') { + next = ','; + continue; + } + } else { + if (explicitKey) { + if (key === undefined && item !== ',') key = null; + explicitKey = false; + } + + if (key !== undefined) { + items.push(new _Pair.default(key)); + key = undefined; + keyStart = null; + + if (item === ',') { + next = ':'; + continue; + } + } + } + + if (item === '}') { + if (i === ast.items.length - 1) continue; + } else if (item === next) { + next = ':'; + continue; + } + + doc.errors.push(new _errors.YAMLSyntaxError(ast, "Flow map contains an unexpected ".concat(item))); + } else if (item.type === _Node.Type.COMMENT) { + comments.push({ + comment: item.comment, + before: items.length + }); + } 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.default(key, doc.resolveNode(item))); + key = undefined; + explicitKey = false; + } + } + + if (ast.items[ast.items.length - 1] !== '}') doc.errors.push(new _errors.YAMLSemanticError(ast, 'Expected flow map to end with }')); + if (key !== undefined) items.push(new _Pair.default(key)); + return { + comments: comments, + items: items + }; +} \ No newline at end of file diff --git a/dist/schema/parseSeq.js b/dist/schema/parseSeq.js new file mode 100644 index 00000000..954806af --- /dev/null +++ b/dist/schema/parseSeq.js @@ -0,0 +1,131 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.default = parseSeq; + +var _Node = require("../ast/Node"); + +var _errors = require("../errors"); + +var _Pair = _interopRequireDefault(require("./Pair")); + +var _parseUtils = require("./parseUtils"); + +var _Seq = _interopRequireDefault(require("./Seq")); + +function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } + +function parseSeq(doc, ast) { + var _ref = ast.type === _Node.Type.FLOW_SEQ ? resolveFlowSeqItems(doc, ast) : resolveBlockSeqItems(doc, ast), + comments = _ref.comments, + items = _ref.items; + + var seq = new _Seq.default(); + seq.items = items; + (0, _parseUtils.resolveComments)(seq, comments); + ast.resolved = seq; + return seq; +} + +function resolveBlockSeqItems(doc, ast) { + var comments = []; + var items = []; + + for (var i = 0; i < ast.items.length; ++i) { + var item = ast.items[i]; + + switch (item.type) { + case _Node.Type.COMMENT: + comments.push({ + comment: item.comment, + before: items.length + }); + break; + + case _Node.Type.SEQ_ITEM: + if (item.error) doc.errors.push(item.error); + items.push(doc.resolveNode(item.node)); + if (item.hasProps) doc.errors.push(new _errors.YAMLSemanticError(item, 'Sequence items cannot have tags or anchors before the - indicator')); + break; + + default: + doc.errors.push(new _errors.YAMLSyntaxError(item, "Unexpected ".concat(item.type, " node in sequence"))); + } + } + + return { + comments: comments, + items: items + }; +} + +function resolveFlowSeqItems(doc, ast) { + var comments = []; + var items = []; + var explicitKey = false; + var key = undefined; + var keyStart = null; + var next = '['; + + for (var i = 0; i < ast.items.length; ++i) { + var item = ast.items[i]; + + if (typeof item === 'string') { + if (item !== ':' && (explicitKey || key !== undefined)) { + if (explicitKey && key === undefined) key = null; + items.push(new _Pair.default(key)); + explicitKey = false; + key = undefined; + keyStart = null; + } + + if (item === next) { + next = null; + } else if (!next && item === '?') { + explicitKey = true; + } else if (next !== '[' && item === ':' && key === undefined) { + if (next === ',') { + key = items.pop(); + if (key instanceof _Pair.default) doc.errors.push(new _errors.YAMLSemanticError(item, 'Chaining flow sequence pairs is invalid (e.g. [ a : b : c ])')); + if (!explicitKey) (0, _parseUtils.checkKeyLength)(doc.errors, ast, i, key, keyStart); + } else { + key = null; + } + + keyStart = null; + explicitKey = false; // TODO: add error for non-explicit multiline plain key + + next = null; + } else if (next === '[' || item !== ']' || i < ast.items.length - 1) { + doc.errors.push(new _errors.YAMLSyntaxError(ast, "Flow sequence contains an unexpected ".concat(item))); + } + } else if (item.type === _Node.Type.COMMENT) { + comments.push({ + comment: item.comment, + before: items.length + }); + } else { + if (next) doc.errors.push(new _errors.YAMLSemanticError(item, "Expected a ".concat(next, " here in flow sequence"))); + var value = doc.resolveNode(item); + + if (key === undefined) { + items.push(value); + } else { + items.push(new _Pair.default(key, value)); + key = undefined; + } + + keyStart = item.range.start; + next = ','; + } + } + + if (ast.items[ast.items.length - 1] !== ']') doc.errors.push(new _errors.YAMLSemanticError(ast, 'Expected flow sequence to end with ]')); + if (key !== undefined) items.push(new _Pair.default(key)); + return { + comments: comments, + items: items + }; +} \ No newline at end of file diff --git a/dist/schema/parseUtils.js b/dist/schema/parseUtils.js new file mode 100644 index 00000000..c514b29c --- /dev/null +++ b/dist/schema/parseUtils.js @@ -0,0 +1,45 @@ +"use strict"; + +Object.defineProperty(exports, "__esModule", { + value: true +}); +exports.checkKeyLength = checkKeyLength; +exports.resolveComments = resolveComments; + +var _errors = require("../errors"); + +function checkKeyLength(errors, node, itemIdx, key, keyStart) { + if (typeof keyStart !== 'number') return; + var item = node.items[itemIdx]; + var keyEnd = item && item.range && item.range.start; + + if (!keyEnd) { + for (var i = itemIdx - 1; i >= 0; --i) { + var it = node.items[i]; + + if (it && it.range) { + keyEnd = it.range.end + 2 * (itemIdx - i); + break; + } + } + } + + if (keyEnd > keyStart + 1024) { + var k = String(key).substr(0, 8) + '...' + String(key).substr(-8); + errors.push(new _errors.YAMLSemanticError(node, "The \"".concat(k, "\" key is too long"))); + } +} + +function resolveComments(collection, comments) { + comments.forEach(function (_ref) { + var comment = _ref.comment, + before = _ref.before; + var item = collection.items[before]; + + if (!item) { + if (collection.comment) collection.comment += '\n' + comment;else collection.comment = comment; + } else { + if (item.commentBefore) item.commentBefore += '\n' + comment;else item.commentBefore = comment; + } + }); +} \ No newline at end of file diff --git a/package-lock.json b/package-lock.json index 6beed2c6..58c8b510 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,6 +1,6 @@ { "name": "yaml", - "version": "1.0.0-beta.5", + "version": "1.0.0-rc.3", "lockfileVersion": 1, "requires": true, "dependencies": {