mirror of
https://github.com/Instadapp/Swap-Aggregator-Subgraph.git
synced 2024-07-29 21:57:12 +00:00
824 lines
26 KiB
JavaScript
824 lines
26 KiB
JavaScript
import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
|
|
import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
|
|
import _createClass from "@babel/runtime/helpers/createClass";
|
|
import _defineProperty from "@babel/runtime/helpers/defineProperty";
|
|
|
|
function _createForOfIteratorHelper(o) { if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (o = _unsupportedIterableToArray(o))) { var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var it, normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
|
|
|
|
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(n); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
|
|
|
|
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
|
|
|
|
import { addComment } from './addComment';
|
|
import { Anchors } from './Anchors';
|
|
import { Char, Type } from './constants';
|
|
import { YAMLError, YAMLReferenceError, YAMLSemanticError, YAMLSyntaxError, YAMLWarning } from './errors';
|
|
import { listTagNames } from './listTagNames';
|
|
import { Schema } from './schema';
|
|
import { Alias } from './schema/Alias';
|
|
import { Collection, isEmptyPath } from './schema/Collection';
|
|
import { Node } from './schema/Node';
|
|
import { Scalar } from './schema/Scalar';
|
|
import { toJSON as _toJSON } from './toJSON';
|
|
|
|
var isCollectionItem = function isCollectionItem(node) {
|
|
return node && [Type.MAP_KEY, Type.MAP_VALUE, Type.SEQ_ITEM].includes(node.type);
|
|
};
|
|
|
|
export var Document = /*#__PURE__*/function () {
|
|
function Document(options) {
|
|
_classCallCheck(this, Document);
|
|
|
|
this.anchors = new Anchors(options.anchorPrefix);
|
|
this.commentBefore = null;
|
|
this.comment = null;
|
|
this.contents = null;
|
|
this.directivesEndMarker = null;
|
|
this.errors = [];
|
|
this.options = options;
|
|
this.schema = null;
|
|
this.tagPrefixes = [];
|
|
this.version = null;
|
|
this.warnings = [];
|
|
}
|
|
|
|
_createClass(Document, [{
|
|
key: "assertCollectionContents",
|
|
value: function assertCollectionContents() {
|
|
if (this.contents instanceof Collection) return true;
|
|
throw new Error('Expected a YAML collection as document contents');
|
|
}
|
|
}, {
|
|
key: "add",
|
|
value: function add(value) {
|
|
this.assertCollectionContents();
|
|
return this.contents.add(value);
|
|
}
|
|
}, {
|
|
key: "addIn",
|
|
value: function addIn(path, value) {
|
|
this.assertCollectionContents();
|
|
this.contents.addIn(path, value);
|
|
}
|
|
}, {
|
|
key: "delete",
|
|
value: function _delete(key) {
|
|
this.assertCollectionContents();
|
|
return this.contents.delete(key);
|
|
}
|
|
}, {
|
|
key: "deleteIn",
|
|
value: function deleteIn(path) {
|
|
if (isEmptyPath(path)) {
|
|
if (this.contents == null) return false;
|
|
this.contents = null;
|
|
return true;
|
|
}
|
|
|
|
this.assertCollectionContents();
|
|
return this.contents.deleteIn(path);
|
|
}
|
|
}, {
|
|
key: "getDefaults",
|
|
value: function getDefaults() {
|
|
return Document.defaults[this.version] || Document.defaults[this.options.version] || {};
|
|
}
|
|
}, {
|
|
key: "get",
|
|
value: function get(key, keepScalar) {
|
|
return this.contents instanceof Collection ? this.contents.get(key, keepScalar) : undefined;
|
|
}
|
|
}, {
|
|
key: "getIn",
|
|
value: function getIn(path, keepScalar) {
|
|
if (isEmptyPath(path)) return !keepScalar && this.contents instanceof Scalar ? this.contents.value : this.contents;
|
|
return this.contents instanceof Collection ? this.contents.getIn(path, keepScalar) : undefined;
|
|
}
|
|
}, {
|
|
key: "has",
|
|
value: function has(key) {
|
|
return this.contents instanceof Collection ? this.contents.has(key) : false;
|
|
}
|
|
}, {
|
|
key: "hasIn",
|
|
value: function hasIn(path) {
|
|
if (isEmptyPath(path)) return this.contents !== undefined;
|
|
return this.contents instanceof Collection ? this.contents.hasIn(path) : false;
|
|
}
|
|
}, {
|
|
key: "set",
|
|
value: function set(key, value) {
|
|
this.assertCollectionContents();
|
|
this.contents.set(key, value);
|
|
}
|
|
}, {
|
|
key: "setIn",
|
|
value: function setIn(path, value) {
|
|
if (isEmptyPath(path)) this.contents = value;else {
|
|
this.assertCollectionContents();
|
|
this.contents.setIn(path, value);
|
|
}
|
|
}
|
|
}, {
|
|
key: "setSchema",
|
|
value: function setSchema(id, customTags) {
|
|
if (!id && !customTags && this.schema) return;
|
|
if (typeof id === 'number') id = id.toFixed(1);
|
|
|
|
if (id === '1.0' || id === '1.1' || id === '1.2') {
|
|
if (this.version) this.version = id;else this.options.version = id;
|
|
delete this.options.schema;
|
|
} else if (id && typeof id === 'string') {
|
|
this.options.schema = id;
|
|
}
|
|
|
|
if (Array.isArray(customTags)) this.options.customTags = customTags;
|
|
var opt = Object.assign({}, this.getDefaults(), this.options);
|
|
this.schema = new Schema(opt);
|
|
}
|
|
}, {
|
|
key: "parse",
|
|
value: function parse(node, prevDoc) {
|
|
if (this.options.keepCstNodes) this.cstNode = node;
|
|
if (this.options.keepNodeTypes) this.type = 'DOCUMENT';
|
|
var _node$directives = node.directives,
|
|
directives = _node$directives === void 0 ? [] : _node$directives,
|
|
_node$contents = node.contents,
|
|
contents = _node$contents === void 0 ? [] : _node$contents,
|
|
directivesEndMarker = node.directivesEndMarker,
|
|
error = node.error,
|
|
valueRange = node.valueRange;
|
|
|
|
if (error) {
|
|
if (!error.source) error.source = this;
|
|
this.errors.push(error);
|
|
}
|
|
|
|
this.parseDirectives(directives, prevDoc);
|
|
if (directivesEndMarker) this.directivesEndMarker = true;
|
|
this.range = valueRange ? [valueRange.start, valueRange.end] : null;
|
|
this.setSchema();
|
|
this.anchors._cstAliases = [];
|
|
this.parseContents(contents);
|
|
this.anchors.resolveNodes();
|
|
|
|
if (this.options.prettyErrors) {
|
|
var _iterator = _createForOfIteratorHelper(this.errors),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var _error = _step.value;
|
|
if (_error instanceof YAMLError) _error.makePretty();
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
|
|
var _iterator2 = _createForOfIteratorHelper(this.warnings),
|
|
_step2;
|
|
|
|
try {
|
|
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
|
|
var warn = _step2.value;
|
|
if (warn instanceof YAMLError) warn.makePretty();
|
|
}
|
|
} catch (err) {
|
|
_iterator2.e(err);
|
|
} finally {
|
|
_iterator2.f();
|
|
}
|
|
}
|
|
|
|
return this;
|
|
}
|
|
}, {
|
|
key: "parseDirectives",
|
|
value: function parseDirectives(directives, prevDoc) {
|
|
var _this = this;
|
|
|
|
var directiveComments = [];
|
|
var hasDirectives = false;
|
|
directives.forEach(function (directive) {
|
|
var comment = directive.comment,
|
|
name = directive.name;
|
|
|
|
switch (name) {
|
|
case 'TAG':
|
|
_this.resolveTagDirective(directive);
|
|
|
|
hasDirectives = true;
|
|
break;
|
|
|
|
case 'YAML':
|
|
case 'YAML:1.0':
|
|
_this.resolveYamlDirective(directive);
|
|
|
|
hasDirectives = true;
|
|
break;
|
|
|
|
default:
|
|
if (name) {
|
|
var msg = "YAML only supports %TAG and %YAML directives, and not %".concat(name);
|
|
|
|
_this.warnings.push(new YAMLWarning(directive, msg));
|
|
}
|
|
|
|
}
|
|
|
|
if (comment) directiveComments.push(comment);
|
|
});
|
|
|
|
if (prevDoc && !hasDirectives && '1.1' === (this.version || prevDoc.version || this.options.version)) {
|
|
var copyTagPrefix = function copyTagPrefix(_ref) {
|
|
var handle = _ref.handle,
|
|
prefix = _ref.prefix;
|
|
return {
|
|
handle: handle,
|
|
prefix: prefix
|
|
};
|
|
};
|
|
|
|
this.tagPrefixes = prevDoc.tagPrefixes.map(copyTagPrefix);
|
|
this.version = prevDoc.version;
|
|
}
|
|
|
|
this.commentBefore = directiveComments.join('\n') || null;
|
|
}
|
|
}, {
|
|
key: "parseContents",
|
|
value: function parseContents(contents) {
|
|
var _this2 = this;
|
|
|
|
var comments = {
|
|
before: [],
|
|
after: []
|
|
};
|
|
var contentNodes = [];
|
|
var spaceBefore = false;
|
|
contents.forEach(function (node) {
|
|
if (node.valueRange) {
|
|
if (contentNodes.length === 1) {
|
|
var msg = 'Document is not valid YAML (bad indentation?)';
|
|
|
|
_this2.errors.push(new YAMLSyntaxError(node, msg));
|
|
}
|
|
|
|
var res = _this2.resolveNode(node);
|
|
|
|
if (spaceBefore) {
|
|
res.spaceBefore = true;
|
|
spaceBefore = false;
|
|
}
|
|
|
|
contentNodes.push(res);
|
|
} else if (node.comment !== null) {
|
|
var cc = contentNodes.length === 0 ? comments.before : comments.after;
|
|
cc.push(node.comment);
|
|
} else if (node.type === Type.BLANK_LINE) {
|
|
spaceBefore = true;
|
|
|
|
if (contentNodes.length === 0 && comments.before.length > 0 && !_this2.commentBefore) {
|
|
// space-separated comments at start are parsed as document comments
|
|
_this2.commentBefore = comments.before.join('\n');
|
|
comments.before = [];
|
|
}
|
|
}
|
|
});
|
|
|
|
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 && 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;
|
|
}
|
|
}, {
|
|
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 {
|
|
var msg = 'The %TAG directive must only be given at most once per handle in the same document.';
|
|
this.errors.push(new YAMLSemanticError(directive, msg));
|
|
}
|
|
} else {
|
|
var _msg = 'Insufficient parameters given for %TAG directive';
|
|
this.errors.push(new YAMLSemanticError(directive, _msg));
|
|
}
|
|
}
|
|
}, {
|
|
key: "resolveYamlDirective",
|
|
value: function resolveYamlDirective(directive) {
|
|
var _directive$parameters2 = _slicedToArray(directive.parameters, 1),
|
|
version = _directive$parameters2[0];
|
|
|
|
if (directive.name === 'YAML:1.0') version = '1.0';
|
|
|
|
if (this.version) {
|
|
var msg = 'The %YAML directive must only be given at most once per document.';
|
|
this.errors.push(new YAMLSemanticError(directive, msg));
|
|
}
|
|
|
|
if (!version) {
|
|
var _msg2 = 'Insufficient parameters given for %YAML directive';
|
|
this.errors.push(new YAMLSemanticError(directive, _msg2));
|
|
} else {
|
|
if (!Document.defaults[version]) {
|
|
var v0 = this.version || this.options.version;
|
|
|
|
var _msg3 = "Document will be parsed as YAML ".concat(v0, " rather than YAML ").concat(version);
|
|
|
|
this.warnings.push(new YAMLWarning(directive, _msg3));
|
|
}
|
|
|
|
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;
|
|
var msg = "Verbatim tags aren't resolved, so ".concat(verbatim, " is invalid.");
|
|
this.errors.push(new YAMLSemanticError(node, msg));
|
|
} else if (handle === '!' && !suffix) {
|
|
nonSpecific = true;
|
|
} else {
|
|
var prefix = this.tagPrefixes.find(function (p) {
|
|
return p.handle === handle;
|
|
});
|
|
|
|
if (!prefix) {
|
|
var dtp = this.getDefaults().tagPrefixes;
|
|
if (dtp) prefix = dtp.find(function (p) {
|
|
return p.handle === handle;
|
|
});
|
|
}
|
|
|
|
if (prefix) {
|
|
if (suffix) {
|
|
if (handle === '!' && (this.version || this.options.version) === '1.0') {
|
|
if (suffix[0] === '^') return suffix;
|
|
|
|
if (/[:/]/.test(suffix)) {
|
|
// word/foo -> tag:word.yaml.org,2002:foo
|
|
var vocab = suffix.match(/^([a-z0-9-]+)\/(.*)/i);
|
|
return vocab ? "tag:".concat(vocab[1], ".yaml.org,2002:").concat(vocab[2]) : "tag:".concat(suffix);
|
|
}
|
|
}
|
|
|
|
return prefix.prefix + decodeURIComponent(suffix);
|
|
}
|
|
|
|
this.errors.push(new YAMLSemanticError(node, "The ".concat(handle, " tag has no suffix.")));
|
|
} else {
|
|
var _msg4 = "The ".concat(handle, " tag handle is non-default and was not declared.");
|
|
|
|
this.errors.push(new YAMLSemanticError(node, _msg4));
|
|
}
|
|
}
|
|
}
|
|
|
|
switch (type) {
|
|
case Type.BLOCK_FOLDED:
|
|
case Type.BLOCK_LITERAL:
|
|
case Type.QUOTE_DOUBLE:
|
|
case Type.QUOTE_SINGLE:
|
|
return Schema.defaultTags.STR;
|
|
|
|
case Type.FLOW_MAP:
|
|
case Type.MAP:
|
|
return Schema.defaultTags.MAP;
|
|
|
|
case Type.FLOW_SEQ:
|
|
case Type.SEQ:
|
|
return Schema.defaultTags.SEQ;
|
|
|
|
case 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;
|
|
|
|
var _iterator3 = _createForOfIteratorHelper(props),
|
|
_step3;
|
|
|
|
try {
|
|
for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
|
|
var _step3$value = _step3.value,
|
|
start = _step3$value.start,
|
|
end = _step3$value.end;
|
|
|
|
switch (node.context.src[start]) {
|
|
case Char.COMMENT:
|
|
{
|
|
if (!node.commentHasRequiredWhitespace(start)) {
|
|
var _msg7 = 'Comments must be separated from other tokens by white space characters';
|
|
errors.push(new YAMLSemanticError(node, _msg7));
|
|
}
|
|
|
|
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 Char.ANCHOR:
|
|
if (hasAnchor) {
|
|
var _msg8 = 'A node can have at most one anchor';
|
|
errors.push(new YAMLSemanticError(node, _msg8));
|
|
}
|
|
|
|
hasAnchor = true;
|
|
break;
|
|
|
|
case Char.TAG:
|
|
if (hasTag) {
|
|
var _msg9 = 'A node can have at most one tag';
|
|
errors.push(new YAMLSemanticError(node, _msg9));
|
|
}
|
|
|
|
hasTag = true;
|
|
break;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator3.e(err);
|
|
} finally {
|
|
_iterator3.f();
|
|
}
|
|
|
|
if (hasAnchor) {
|
|
var name = node.anchor;
|
|
var prev = anchors.getNode(name); // At this point, aliases for any preceding node with the same anchor
|
|
// name have already been resolved, so it may safely be renamed.
|
|
|
|
if (prev) anchors.map[anchors.newName(name)] = prev; // During parsing, we need to store the CST node in anchors.map as
|
|
// anchors need to be available during resolution to allow for
|
|
// circular references.
|
|
|
|
anchors.map[name] = node;
|
|
}
|
|
|
|
var res;
|
|
|
|
if (node.type === Type.ALIAS) {
|
|
if (hasAnchor || hasTag) {
|
|
var msg = 'An alias node must not specify any properties';
|
|
errors.push(new YAMLSemanticError(node, msg));
|
|
}
|
|
|
|
var _name = node.rawValue;
|
|
var src = anchors.getNode(_name);
|
|
|
|
if (!src) {
|
|
var _msg5 = "Aliased anchor not found: ".concat(_name);
|
|
|
|
errors.push(new YAMLReferenceError(node, _msg5));
|
|
return null;
|
|
} // Lazy resolution for circular references
|
|
|
|
|
|
res = new Alias(src);
|
|
|
|
anchors._cstAliases.push(res);
|
|
} else {
|
|
var tagName = this.resolveTagName(node);
|
|
|
|
if (tagName) {
|
|
res = schema.resolveNodeWithFallback(this, node, tagName);
|
|
} else {
|
|
if (node.type !== Type.PLAIN) {
|
|
var _msg6 = "Failed to resolve ".concat(node.type, " node here");
|
|
|
|
errors.push(new YAMLSyntaxError(node, _msg6));
|
|
return null;
|
|
}
|
|
|
|
try {
|
|
res = schema.resolveScalar(node.strValue || '');
|
|
} catch (error) {
|
|
if (!error.source) error.source = node;
|
|
errors.push(error);
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (res) {
|
|
res.range = [node.range.start, node.range.end];
|
|
if (this.options.keepCstNodes) res.cstNode = node;
|
|
if (this.options.keepNodeTypes) res.type = node.type;
|
|
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() {
|
|
return listTagNames(this.contents).filter(function (t) {
|
|
return t.indexOf(Schema.defaultPrefix) !== 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: "stringifyTag",
|
|
value: function stringifyTag(tag) {
|
|
if ((this.version || this.options.version) === '1.0') {
|
|
var priv = tag.match(/^tag:private\.yaml\.org,2002:([^:/]+)$/);
|
|
if (priv) return '!' + priv[1];
|
|
var vocab = tag.match(/^tag:([a-zA-Z0-9-]+)\.yaml\.org,2002:(.*)/);
|
|
return vocab ? "!".concat(vocab[1], "/").concat(vocab[2]) : "!".concat(tag.replace(/^tag:/, ''));
|
|
} else {
|
|
var p = this.tagPrefixes.find(function (p) {
|
|
return tag.indexOf(p.prefix) === 0;
|
|
});
|
|
|
|
if (!p) {
|
|
var dtp = this.getDefaults().tagPrefixes;
|
|
p = dtp && dtp.find(function (p) {
|
|
return tag.indexOf(p.prefix) === 0;
|
|
});
|
|
}
|
|
|
|
if (!p) return tag[0] === '!' ? tag : "!<".concat(tag, ">");
|
|
var suffix = tag.substr(p.prefix.length).replace(/[!,[\]{}]/g, function (ch) {
|
|
return {
|
|
'!': '%21',
|
|
',': '%2C',
|
|
'[': '%5B',
|
|
']': '%5D',
|
|
'{': '%7B',
|
|
'}': '%7D'
|
|
}[ch];
|
|
});
|
|
return p.handle + suffix;
|
|
}
|
|
}
|
|
}, {
|
|
key: "toJSON",
|
|
value: function toJSON(arg, onAnchor) {
|
|
var _this3 = this;
|
|
|
|
var _this$options = this.options,
|
|
keepBlobsInJSON = _this$options.keepBlobsInJSON,
|
|
mapAsMap = _this$options.mapAsMap,
|
|
maxAliasCount = _this$options.maxAliasCount;
|
|
var keep = keepBlobsInJSON && (typeof arg !== 'string' || !(this.contents instanceof Scalar));
|
|
var ctx = {
|
|
doc: this,
|
|
indentStep: ' ',
|
|
keep: keep,
|
|
mapAsMap: keep && !!mapAsMap,
|
|
maxAliasCount: maxAliasCount
|
|
};
|
|
var anchorNames = Object.keys(this.anchors.map);
|
|
if (anchorNames.length > 0) ctx.anchors = new Map(anchorNames.map(function (name) {
|
|
return [_this3.anchors.map[name], {
|
|
alias: [],
|
|
aliasCount: 0,
|
|
count: 1
|
|
}];
|
|
}));
|
|
|
|
var res = _toJSON(this.contents, arg, ctx);
|
|
|
|
if (typeof onAnchor === 'function' && ctx.anchors) {
|
|
var _iterator4 = _createForOfIteratorHelper(ctx.anchors.values()),
|
|
_step4;
|
|
|
|
try {
|
|
for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
|
|
var _step4$value = _step4.value,
|
|
count = _step4$value.count,
|
|
_res = _step4$value.res;
|
|
onAnchor(_res, count);
|
|
}
|
|
} catch (err) {
|
|
_iterator4.e(err);
|
|
} finally {
|
|
_iterator4.f();
|
|
}
|
|
}
|
|
|
|
return res;
|
|
}
|
|
}, {
|
|
key: "toString",
|
|
value: function toString() {
|
|
if (this.errors.length > 0) throw new Error('Document with errors cannot be stringified');
|
|
var indentSize = this.options.indent;
|
|
|
|
if (!Number.isInteger(indentSize) || indentSize <= 0) {
|
|
var s = JSON.stringify(indentSize);
|
|
throw new Error("\"indent\" option must be a positive integer, not ".concat(s));
|
|
}
|
|
|
|
this.setSchema();
|
|
var lines = [];
|
|
var hasDirectives = false;
|
|
|
|
if (this.version) {
|
|
var vd = '%YAML 1.2';
|
|
|
|
if (this.schema.name === 'yaml-1.1') {
|
|
if (this.version === '1.0') vd = '%YAML:1.0';else if (this.version === '1.1') vd = '%YAML 1.1';
|
|
}
|
|
|
|
lines.push(vd);
|
|
hasDirectives = true;
|
|
}
|
|
|
|
var tagNames = this.listNonDefaultTags();
|
|
this.tagPrefixes.forEach(function (_ref2) {
|
|
var handle = _ref2.handle,
|
|
prefix = _ref2.prefix;
|
|
|
|
if (tagNames.some(function (t) {
|
|
return t.indexOf(prefix) === 0;
|
|
})) {
|
|
lines.push("%TAG ".concat(handle, " ").concat(prefix));
|
|
hasDirectives = true;
|
|
}
|
|
});
|
|
if (hasDirectives || this.directivesEndMarker) lines.push('---');
|
|
|
|
if (this.commentBefore) {
|
|
if (hasDirectives || !this.directivesEndMarker) lines.unshift('');
|
|
lines.unshift(this.commentBefore.replace(/^/gm, '#'));
|
|
}
|
|
|
|
var ctx = {
|
|
anchors: {},
|
|
doc: this,
|
|
indent: '',
|
|
indentStep: ' '.repeat(indentSize)
|
|
};
|
|
var chompKeep = false;
|
|
var contentComment = null;
|
|
|
|
if (this.contents) {
|
|
if (this.contents instanceof Node) {
|
|
if (this.contents.spaceBefore && (hasDirectives || this.directivesEndMarker)) lines.push('');
|
|
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;
|
|
contentComment = this.contents.comment;
|
|
}
|
|
|
|
var onChompKeep = contentComment ? null : function () {
|
|
return chompKeep = true;
|
|
};
|
|
var body = this.schema.stringify(this.contents, ctx, function () {
|
|
return contentComment = null;
|
|
}, onChompKeep);
|
|
lines.push(addComment(body, '', contentComment));
|
|
} else if (this.contents !== undefined) {
|
|
lines.push(this.schema.stringify(this.contents, ctx));
|
|
}
|
|
|
|
if (this.comment) {
|
|
if ((!chompKeep || contentComment) && lines[lines.length - 1] !== '') lines.push('');
|
|
lines.push(this.comment.replace(/^/gm, '#'));
|
|
}
|
|
|
|
return lines.join('\n') + '\n';
|
|
}
|
|
}]);
|
|
|
|
return Document;
|
|
}();
|
|
|
|
_defineProperty(Document, "defaults", {
|
|
'1.0': {
|
|
schema: 'yaml-1.1',
|
|
merge: true,
|
|
tagPrefixes: [{
|
|
handle: '!',
|
|
prefix: Schema.defaultPrefix
|
|
}, {
|
|
handle: '!!',
|
|
prefix: 'tag:private.yaml.org,2002:'
|
|
}]
|
|
},
|
|
'1.1': {
|
|
schema: 'yaml-1.1',
|
|
merge: true,
|
|
tagPrefixes: [{
|
|
handle: '!',
|
|
prefix: '!'
|
|
}, {
|
|
handle: '!!',
|
|
prefix: Schema.defaultPrefix
|
|
}]
|
|
},
|
|
'1.2': {
|
|
schema: 'core',
|
|
merge: false,
|
|
tagPrefixes: [{
|
|
handle: '!',
|
|
prefix: '!'
|
|
}, {
|
|
handle: '!!',
|
|
prefix: Schema.defaultPrefix
|
|
}]
|
|
}
|
|
}); |