mirror of
https://github.com/dawidd6/action-ansible-playbook.git
synced 2024-11-25 18:07:47 +00:00
1004 lines
27 KiB
JavaScript
1004 lines
27 KiB
JavaScript
import { d as defaultTagPrefix, _ as _createForOfIteratorHelper, a as _typeof, b as _createClass, c as _classCallCheck, e as _defineProperty, Y as YAMLSyntaxError, T as Type, f as YAMLWarning, g as YAMLSemanticError, h as _slicedToArray, i as YAMLError, j as _inherits, k as _createSuper } from './PlainValue-ff5147c6.js';
|
|
import { parse as parse$1 } from './parse-cst.js';
|
|
import { b as binaryOptions, a as boolOptions, i as intOptions, n as nullOptions, s as strOptions, N as Node, P as Pair, S as Scalar, c as stringifyString, A as Alias, Y as YAMLSeq, d as YAMLMap, M as Merge, C as Collection, r as resolveNode, e as isEmptyPath, t as toJSON, f as addComment } from './resolveSeq-04825f30.js';
|
|
import { S as Schema } from './Schema-2bf2c74e.js';
|
|
import { w as warn } from './warnings-0e4b70d3.js';
|
|
|
|
var defaultOptions = {
|
|
anchorPrefix: 'a',
|
|
customTags: null,
|
|
indent: 2,
|
|
indentSeq: true,
|
|
keepCstNodes: false,
|
|
keepNodeTypes: true,
|
|
keepBlobsInJSON: true,
|
|
mapAsMap: false,
|
|
maxAliasCount: 100,
|
|
prettyErrors: false,
|
|
// TODO Set true in v2
|
|
simpleKeys: false,
|
|
version: '1.2'
|
|
};
|
|
var scalarOptions = {
|
|
get binary() {
|
|
return binaryOptions;
|
|
},
|
|
|
|
set binary(opt) {
|
|
Object.assign(binaryOptions, opt);
|
|
},
|
|
|
|
get bool() {
|
|
return boolOptions;
|
|
},
|
|
|
|
set bool(opt) {
|
|
Object.assign(boolOptions, opt);
|
|
},
|
|
|
|
get int() {
|
|
return intOptions;
|
|
},
|
|
|
|
set int(opt) {
|
|
Object.assign(intOptions, opt);
|
|
},
|
|
|
|
get null() {
|
|
return nullOptions;
|
|
},
|
|
|
|
set null(opt) {
|
|
Object.assign(nullOptions, opt);
|
|
},
|
|
|
|
get str() {
|
|
return strOptions;
|
|
},
|
|
|
|
set str(opt) {
|
|
Object.assign(strOptions, opt);
|
|
}
|
|
|
|
};
|
|
var documentOptions = {
|
|
'1.0': {
|
|
schema: 'yaml-1.1',
|
|
merge: true,
|
|
tagPrefixes: [{
|
|
handle: '!',
|
|
prefix: defaultTagPrefix
|
|
}, {
|
|
handle: '!!',
|
|
prefix: 'tag:private.yaml.org,2002:'
|
|
}]
|
|
},
|
|
'1.1': {
|
|
schema: 'yaml-1.1',
|
|
merge: true,
|
|
tagPrefixes: [{
|
|
handle: '!',
|
|
prefix: '!'
|
|
}, {
|
|
handle: '!!',
|
|
prefix: defaultTagPrefix
|
|
}]
|
|
},
|
|
'1.2': {
|
|
schema: 'core',
|
|
merge: false,
|
|
tagPrefixes: [{
|
|
handle: '!',
|
|
prefix: '!'
|
|
}, {
|
|
handle: '!!',
|
|
prefix: defaultTagPrefix
|
|
}]
|
|
}
|
|
};
|
|
|
|
function stringifyTag(doc, tag) {
|
|
if ((doc.version || doc.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:/, ''));
|
|
}
|
|
|
|
var p = doc.tagPrefixes.find(function (p) {
|
|
return tag.indexOf(p.prefix) === 0;
|
|
});
|
|
|
|
if (!p) {
|
|
var dtp = doc.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;
|
|
}
|
|
|
|
function getTagObject(tags, item) {
|
|
if (item instanceof Alias) return Alias;
|
|
|
|
if (item.tag) {
|
|
var match = tags.filter(function (t) {
|
|
return t.tag === item.tag;
|
|
});
|
|
if (match.length > 0) return match.find(function (t) {
|
|
return t.format === item.format;
|
|
}) || match[0];
|
|
}
|
|
|
|
var tagObj, obj;
|
|
|
|
if (item instanceof Scalar) {
|
|
obj = item.value; // TODO: deprecate/remove class check
|
|
|
|
var _match = tags.filter(function (t) {
|
|
return t.identify && t.identify(obj) || t.class && obj instanceof t.class;
|
|
});
|
|
|
|
tagObj = _match.find(function (t) {
|
|
return t.format === item.format;
|
|
}) || _match.find(function (t) {
|
|
return !t.format;
|
|
});
|
|
} else {
|
|
obj = item;
|
|
tagObj = tags.find(function (t) {
|
|
return t.nodeClass && obj instanceof t.nodeClass;
|
|
});
|
|
}
|
|
|
|
if (!tagObj) {
|
|
var name = obj && obj.constructor ? obj.constructor.name : _typeof(obj);
|
|
throw new Error("Tag not resolved for ".concat(name, " value"));
|
|
}
|
|
|
|
return tagObj;
|
|
} // needs to be called before value stringifier to allow for circular anchor refs
|
|
|
|
|
|
function stringifyProps(node, tagObj, _ref) {
|
|
var anchors = _ref.anchors,
|
|
doc = _ref.doc;
|
|
var props = [];
|
|
var anchor = doc.anchors.getName(node);
|
|
|
|
if (anchor) {
|
|
anchors[anchor] = node;
|
|
props.push("&".concat(anchor));
|
|
}
|
|
|
|
if (node.tag) {
|
|
props.push(stringifyTag(doc, node.tag));
|
|
} else if (!tagObj.default) {
|
|
props.push(stringifyTag(doc, tagObj.tag));
|
|
}
|
|
|
|
return props.join(' ');
|
|
}
|
|
|
|
function stringify(item, ctx, onComment, onChompKeep) {
|
|
var _ctx$doc = ctx.doc,
|
|
anchors = _ctx$doc.anchors,
|
|
schema = _ctx$doc.schema;
|
|
var tagObj;
|
|
|
|
if (!(item instanceof Node)) {
|
|
var createCtx = {
|
|
aliasNodes: [],
|
|
onTagObj: function onTagObj(o) {
|
|
return tagObj = o;
|
|
},
|
|
prevObjects: new Map()
|
|
};
|
|
item = schema.createNode(item, true, null, createCtx);
|
|
|
|
var _iterator = _createForOfIteratorHelper(createCtx.aliasNodes),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var alias = _step.value;
|
|
alias.source = alias.source.node;
|
|
var name = anchors.getName(alias.source);
|
|
|
|
if (!name) {
|
|
name = anchors.newName();
|
|
anchors.map[name] = alias.source;
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
}
|
|
|
|
if (item instanceof Pair) return item.toString(ctx, onComment, onChompKeep);
|
|
if (!tagObj) tagObj = getTagObject(schema.tags, item);
|
|
var props = stringifyProps(item, tagObj, ctx);
|
|
if (props.length > 0) ctx.indentAtStart = (ctx.indentAtStart || 0) + props.length + 1;
|
|
var str = typeof tagObj.stringify === 'function' ? tagObj.stringify(item, ctx, onComment, onChompKeep) : item instanceof Scalar ? stringifyString(item, ctx, onComment, onChompKeep) : item.toString(ctx, onComment, onChompKeep);
|
|
if (!props) return str;
|
|
return item instanceof Scalar || str[0] === '{' || str[0] === '[' ? "".concat(props, " ").concat(str) : "".concat(props, "\n").concat(ctx.indent).concat(str);
|
|
}
|
|
|
|
var Anchors = /*#__PURE__*/function () {
|
|
_createClass(Anchors, null, [{
|
|
key: "validAnchorNode",
|
|
value: function validAnchorNode(node) {
|
|
return node instanceof Scalar || node instanceof YAMLSeq || node instanceof YAMLMap;
|
|
}
|
|
}]);
|
|
|
|
function Anchors(prefix) {
|
|
_classCallCheck(this, Anchors);
|
|
|
|
_defineProperty(this, "map", {});
|
|
|
|
this.prefix = prefix;
|
|
}
|
|
|
|
_createClass(Anchors, [{
|
|
key: "createAlias",
|
|
value: function createAlias(node, name) {
|
|
this.setAnchor(node, name);
|
|
return new Alias(node);
|
|
}
|
|
}, {
|
|
key: "createMergePair",
|
|
value: function createMergePair() {
|
|
var _this = this;
|
|
|
|
var merge = new Merge();
|
|
|
|
for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
sources[_key] = arguments[_key];
|
|
}
|
|
|
|
merge.value.items = sources.map(function (s) {
|
|
if (s instanceof Alias) {
|
|
if (s.source instanceof YAMLMap) return s;
|
|
} else if (s instanceof YAMLMap) {
|
|
return _this.createAlias(s);
|
|
}
|
|
|
|
throw new Error('Merge sources must be Map nodes or their Aliases');
|
|
});
|
|
return merge;
|
|
}
|
|
}, {
|
|
key: "getName",
|
|
value: function getName(node) {
|
|
var map = this.map;
|
|
return Object.keys(map).find(function (a) {
|
|
return map[a] === node;
|
|
});
|
|
}
|
|
}, {
|
|
key: "getNames",
|
|
value: function getNames() {
|
|
return Object.keys(this.map);
|
|
}
|
|
}, {
|
|
key: "getNode",
|
|
value: function getNode(name) {
|
|
return this.map[name];
|
|
}
|
|
}, {
|
|
key: "newName",
|
|
value: function newName(prefix) {
|
|
if (!prefix) prefix = this.prefix;
|
|
var names = Object.keys(this.map);
|
|
|
|
for (var i = 1; true; ++i) {
|
|
var name = "".concat(prefix).concat(i);
|
|
if (!names.includes(name)) return name;
|
|
}
|
|
} // During parsing, map & aliases contain CST nodes
|
|
|
|
}, {
|
|
key: "resolveNodes",
|
|
value: function resolveNodes() {
|
|
var map = this.map,
|
|
_cstAliases = this._cstAliases;
|
|
Object.keys(map).forEach(function (a) {
|
|
map[a] = map[a].resolved;
|
|
});
|
|
|
|
_cstAliases.forEach(function (a) {
|
|
a.source = a.source.resolved;
|
|
});
|
|
|
|
delete this._cstAliases;
|
|
}
|
|
}, {
|
|
key: "setAnchor",
|
|
value: function setAnchor(node, name) {
|
|
if (node != null && !Anchors.validAnchorNode(node)) {
|
|
throw new Error('Anchors may only be set for Scalar, Seq and Map nodes');
|
|
}
|
|
|
|
if (name && /[\x00-\x19\s,[\]{}]/.test(name)) {
|
|
throw new Error('Anchor names must not contain whitespace or control characters');
|
|
}
|
|
|
|
var map = this.map;
|
|
var prev = node && Object.keys(map).find(function (a) {
|
|
return map[a] === node;
|
|
});
|
|
|
|
if (prev) {
|
|
if (!name) {
|
|
return prev;
|
|
} else if (prev !== name) {
|
|
delete map[prev];
|
|
map[name] = node;
|
|
}
|
|
} else {
|
|
if (!name) {
|
|
if (!node) return null;
|
|
name = this.newName();
|
|
}
|
|
|
|
map[name] = node;
|
|
}
|
|
|
|
return name;
|
|
}
|
|
}]);
|
|
|
|
return Anchors;
|
|
}();
|
|
|
|
var visit = function visit(node, tags) {
|
|
if (node && _typeof(node) === 'object') {
|
|
var tag = node.tag;
|
|
|
|
if (node instanceof Collection) {
|
|
if (tag) tags[tag] = true;
|
|
node.items.forEach(function (n) {
|
|
return visit(n, tags);
|
|
});
|
|
} else if (node instanceof Pair) {
|
|
visit(node.key, tags);
|
|
visit(node.value, tags);
|
|
} else if (node instanceof Scalar) {
|
|
if (tag) tags[tag] = true;
|
|
}
|
|
}
|
|
|
|
return tags;
|
|
};
|
|
|
|
var listTagNames = function listTagNames(node) {
|
|
return Object.keys(visit(node, {}));
|
|
};
|
|
|
|
function parseContents(doc, contents) {
|
|
var comments = {
|
|
before: [],
|
|
after: []
|
|
};
|
|
var body = undefined;
|
|
var spaceBefore = false;
|
|
|
|
var _iterator = _createForOfIteratorHelper(contents),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var node = _step.value;
|
|
|
|
if (node.valueRange) {
|
|
if (body !== undefined) {
|
|
var msg = 'Document contains trailing content not separated by a ... or --- line';
|
|
doc.errors.push(new YAMLSyntaxError(node, msg));
|
|
break;
|
|
}
|
|
|
|
var res = resolveNode(doc, node);
|
|
|
|
if (spaceBefore) {
|
|
res.spaceBefore = true;
|
|
spaceBefore = false;
|
|
}
|
|
|
|
body = res;
|
|
} else if (node.comment !== null) {
|
|
var cc = body === undefined ? comments.before : comments.after;
|
|
cc.push(node.comment);
|
|
} else if (node.type === Type.BLANK_LINE) {
|
|
spaceBefore = true;
|
|
|
|
if (body === undefined && comments.before.length > 0 && !doc.commentBefore) {
|
|
// space-separated comments at start are parsed as document comments
|
|
doc.commentBefore = comments.before.join('\n');
|
|
comments.before = [];
|
|
}
|
|
}
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
|
|
doc.contents = body || null;
|
|
|
|
if (!body) {
|
|
doc.comment = comments.before.concat(comments.after).join('\n') || null;
|
|
} else {
|
|
var cb = comments.before.join('\n');
|
|
|
|
if (cb) {
|
|
var cbNode = body instanceof Collection && body.items[0] ? body.items[0] : body;
|
|
cbNode.commentBefore = cbNode.commentBefore ? "".concat(cb, "\n").concat(cbNode.commentBefore) : cb;
|
|
}
|
|
|
|
doc.comment = comments.after.join('\n') || null;
|
|
}
|
|
}
|
|
|
|
function resolveTagDirective(_ref, directive) {
|
|
var tagPrefixes = _ref.tagPrefixes;
|
|
|
|
var _directive$parameters = _slicedToArray(directive.parameters, 2),
|
|
handle = _directive$parameters[0],
|
|
prefix = _directive$parameters[1];
|
|
|
|
if (!handle || !prefix) {
|
|
var msg = 'Insufficient parameters given for %TAG directive';
|
|
throw new YAMLSemanticError(directive, msg);
|
|
}
|
|
|
|
if (tagPrefixes.some(function (p) {
|
|
return p.handle === handle;
|
|
})) {
|
|
var _msg = 'The %TAG directive must only be given at most once per handle in the same document.';
|
|
throw new YAMLSemanticError(directive, _msg);
|
|
}
|
|
|
|
return {
|
|
handle: handle,
|
|
prefix: prefix
|
|
};
|
|
}
|
|
|
|
function resolveYamlDirective(doc, directive) {
|
|
var _directive$parameters2 = _slicedToArray(directive.parameters, 1),
|
|
version = _directive$parameters2[0];
|
|
|
|
if (directive.name === 'YAML:1.0') version = '1.0';
|
|
|
|
if (!version) {
|
|
var msg = 'Insufficient parameters given for %YAML directive';
|
|
throw new YAMLSemanticError(directive, msg);
|
|
}
|
|
|
|
if (!documentOptions[version]) {
|
|
var v0 = doc.version || doc.options.version;
|
|
|
|
var _msg2 = "Document will be parsed as YAML ".concat(v0, " rather than YAML ").concat(version);
|
|
|
|
doc.warnings.push(new YAMLWarning(directive, _msg2));
|
|
}
|
|
|
|
return version;
|
|
}
|
|
|
|
function parseDirectives(doc, directives, prevDoc) {
|
|
var directiveComments = [];
|
|
var hasDirectives = false;
|
|
|
|
var _iterator = _createForOfIteratorHelper(directives),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var directive = _step.value;
|
|
var comment = directive.comment,
|
|
name = directive.name;
|
|
|
|
switch (name) {
|
|
case 'TAG':
|
|
try {
|
|
doc.tagPrefixes.push(resolveTagDirective(doc, directive));
|
|
} catch (error) {
|
|
doc.errors.push(error);
|
|
}
|
|
|
|
hasDirectives = true;
|
|
break;
|
|
|
|
case 'YAML':
|
|
case 'YAML:1.0':
|
|
if (doc.version) {
|
|
var msg = 'The %YAML directive must only be given at most once per document.';
|
|
doc.errors.push(new YAMLSemanticError(directive, msg));
|
|
}
|
|
|
|
try {
|
|
doc.version = resolveYamlDirective(doc, directive);
|
|
} catch (error) {
|
|
doc.errors.push(error);
|
|
}
|
|
|
|
hasDirectives = true;
|
|
break;
|
|
|
|
default:
|
|
if (name) {
|
|
var _msg3 = "YAML only supports %TAG and %YAML directives, and not %".concat(name);
|
|
|
|
doc.warnings.push(new YAMLWarning(directive, _msg3));
|
|
}
|
|
|
|
}
|
|
|
|
if (comment) directiveComments.push(comment);
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
|
|
if (prevDoc && !hasDirectives && '1.1' === (doc.version || prevDoc.version || doc.options.version)) {
|
|
var copyTagPrefix = function copyTagPrefix(_ref2) {
|
|
var handle = _ref2.handle,
|
|
prefix = _ref2.prefix;
|
|
return {
|
|
handle: handle,
|
|
prefix: prefix
|
|
};
|
|
};
|
|
|
|
doc.tagPrefixes = prevDoc.tagPrefixes.map(copyTagPrefix);
|
|
doc.version = prevDoc.version;
|
|
}
|
|
|
|
doc.commentBefore = directiveComments.join('\n') || null;
|
|
}
|
|
|
|
function assertCollection(contents) {
|
|
if (contents instanceof Collection) return true;
|
|
throw new Error('Expected a YAML collection as document contents');
|
|
}
|
|
|
|
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: "add",
|
|
value: function add(value) {
|
|
assertCollection(this.contents);
|
|
return this.contents.add(value);
|
|
}
|
|
}, {
|
|
key: "addIn",
|
|
value: function addIn(path, value) {
|
|
assertCollection(this.contents);
|
|
this.contents.addIn(path, value);
|
|
}
|
|
}, {
|
|
key: "delete",
|
|
value: function _delete(key) {
|
|
assertCollection(this.contents);
|
|
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;
|
|
}
|
|
|
|
assertCollection(this.contents);
|
|
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) {
|
|
assertCollection(this.contents);
|
|
this.contents.set(key, value);
|
|
}
|
|
}, {
|
|
key: "setIn",
|
|
value: function setIn(path, value) {
|
|
if (isEmptyPath(path)) this.contents = value;else {
|
|
assertCollection(this.contents);
|
|
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);
|
|
}
|
|
|
|
parseDirectives(this, directives, prevDoc);
|
|
if (directivesEndMarker) this.directivesEndMarker = true;
|
|
this.range = valueRange ? [valueRange.start, valueRange.end] : null;
|
|
this.setSchema();
|
|
this.anchors._cstAliases = [];
|
|
parseContents(this, 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: "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: "toJSON",
|
|
value: function toJSON$1(arg, onAnchor) {
|
|
var _this = 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,
|
|
stringify: stringify // Requiring directly in Pair would create circular dependencies
|
|
|
|
};
|
|
var anchorNames = Object.keys(this.anchors.map);
|
|
if (anchorNames.length > 0) ctx.anchors = new Map(anchorNames.map(function (name) {
|
|
return [_this.anchors.map[name], {
|
|
alias: [],
|
|
aliasCount: 0,
|
|
count: 1
|
|
}];
|
|
}));
|
|
|
|
var res = toJSON(this.contents, arg, ctx);
|
|
|
|
if (typeof onAnchor === 'function' && ctx.anchors) {
|
|
var _iterator3 = _createForOfIteratorHelper(ctx.anchors.values()),
|
|
_step3;
|
|
|
|
try {
|
|
for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
|
|
var _step3$value = _step3.value,
|
|
count = _step3$value.count,
|
|
_res = _step3$value.res;
|
|
onAnchor(_res, count);
|
|
}
|
|
} catch (err) {
|
|
_iterator3.e(err);
|
|
} finally {
|
|
_iterator3.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 (_ref) {
|
|
var handle = _ref.handle,
|
|
prefix = _ref.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),
|
|
stringify: stringify // Requiring directly in nodes would create circular dependencies
|
|
|
|
};
|
|
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 = stringify(this.contents, ctx, function () {
|
|
return contentComment = null;
|
|
}, onChompKeep);
|
|
lines.push(addComment(body, '', contentComment));
|
|
} else if (this.contents !== undefined) {
|
|
lines.push(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", documentOptions);
|
|
|
|
function createNode(value) {
|
|
var wrapScalars = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
|
|
var tag = arguments.length > 2 ? arguments[2] : undefined;
|
|
|
|
if (tag === undefined && typeof wrapScalars === 'string') {
|
|
tag = wrapScalars;
|
|
wrapScalars = true;
|
|
}
|
|
|
|
var options = Object.assign({}, Document.defaults[defaultOptions.version], defaultOptions);
|
|
var schema = new Schema(options);
|
|
return schema.createNode(value, wrapScalars, tag);
|
|
}
|
|
|
|
var Document$1 = /*#__PURE__*/function (_YAMLDocument) {
|
|
_inherits(Document, _YAMLDocument);
|
|
|
|
var _super = _createSuper(Document);
|
|
|
|
function Document(options) {
|
|
_classCallCheck(this, Document);
|
|
|
|
return _super.call(this, Object.assign({}, defaultOptions, options));
|
|
}
|
|
|
|
return Document;
|
|
}(Document);
|
|
|
|
function parseAllDocuments(src, options) {
|
|
var stream = [];
|
|
var prev;
|
|
|
|
var _iterator = _createForOfIteratorHelper(parse$1(src)),
|
|
_step;
|
|
|
|
try {
|
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
var cstDoc = _step.value;
|
|
var doc = new Document$1(options);
|
|
doc.parse(cstDoc, prev);
|
|
stream.push(doc);
|
|
prev = doc;
|
|
}
|
|
} catch (err) {
|
|
_iterator.e(err);
|
|
} finally {
|
|
_iterator.f();
|
|
}
|
|
|
|
return stream;
|
|
}
|
|
|
|
function parseDocument(src, options) {
|
|
var cst = parse$1(src);
|
|
var doc = new Document$1(options).parse(cst[0]);
|
|
|
|
if (cst.length > 1) {
|
|
var errMsg = 'Source contains multiple documents; please use YAML.parseAllDocuments()';
|
|
doc.errors.unshift(new YAMLSemanticError(cst[1], errMsg));
|
|
}
|
|
|
|
return doc;
|
|
}
|
|
|
|
function parse(src, options) {
|
|
var doc = parseDocument(src, options);
|
|
doc.warnings.forEach(function (warning) {
|
|
return warn(warning);
|
|
});
|
|
if (doc.errors.length > 0) throw doc.errors[0];
|
|
return doc.toJSON();
|
|
}
|
|
|
|
function stringify$1(value, options) {
|
|
var doc = new Document$1(options);
|
|
doc.contents = value;
|
|
return String(doc);
|
|
}
|
|
|
|
var YAML = {
|
|
createNode: createNode,
|
|
defaultOptions: defaultOptions,
|
|
Document: Document$1,
|
|
parse: parse,
|
|
parseAllDocuments: parseAllDocuments,
|
|
parseCST: parse$1,
|
|
parseDocument: parseDocument,
|
|
scalarOptions: scalarOptions,
|
|
stringify: stringify$1
|
|
};
|
|
|
|
export { YAML };
|