Comparing version 2.0.0-1 to 2.0.0-2
@@ -1,2005 +0,20 @@ | ||
| import { d as defaultTagPrefix, _ as _typeof, a as _createClass, b as _classCallCheck, c as _defineProperty, e as _slicedToArray, Y as YAMLSemanticError, T as Type, f as defaultTags, g as YAMLWarning, h as _createForOfIteratorHelper, i as YAMLSyntaxError, C as Char, j as YAMLReferenceError, k as YAMLError } from './errors-2634d01a.js'; | ||
| import { P as PlainValue, D as Document$1, p as parse$1 } from './parse-d1ba890f.js'; | ||
| export { p as parseCST } from './parse-d1ba890f.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, C as Collection, r as resolveScalar, e as createNode, f as isEmptyPath, g as collectionFromPath, t as toJS, h as addComment } from './stringifyNumber-d8af95b1.js'; | ||
| import { M as Merge, a as MERGE_KEY, S as Schema } from './Schema-ea978338.js'; | ||
| import { LogLevel } from './constants.js'; | ||
| import { parse as parse$1 } from './cst/parse.js'; | ||
| export { parse as parseCST } from './cst/parse.js'; | ||
| import { Document } from './doc/Document.js'; | ||
| export { Document } from './doc/Document.js'; | ||
| import { YAMLSemanticError } from './errors.js'; | ||
| import { warn } from './log.js'; | ||
| export { defaultOptions, scalarOptions } from './options.js'; | ||
| export { visit } from './ast/visit.js'; | ||
| var defaultOptions = { | ||
| anchorPrefix: 'a', | ||
| customTags: null, | ||
| indent: 2, | ||
| indentSeq: true, | ||
| keepCstNodes: false, | ||
| keepNodeTypes: true, | ||
| keepUndefined: false, | ||
| mapAsMap: false, | ||
| maxAliasCount: 100, | ||
| prettyErrors: true, | ||
| 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, | ||
| resolveKnownTags: true, | ||
| 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; | ||
| var _match = tags.filter(function (t) { | ||
| return t.identify && t.identify(obj); | ||
| }); | ||
| 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 schema = ctx.doc.schema; | ||
| var tagObj; | ||
| if (!(item instanceof Node)) { | ||
| item = ctx.doc.createNode(item, { | ||
| onTagObj: function onTagObj(o) { | ||
| return tagObj = o; | ||
| }, | ||
| wrapScalars: true | ||
| }); | ||
| } | ||
| 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", Object.create(null)); | ||
| 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; | ||
| }(); | ||
| /** | ||
| * Applies the JSON.parse reviver algorithm as defined in the ECMA-262 spec, | ||
| * in section 24.5.1.1 "Runtime Semantics: InternalizeJSONProperty" of the | ||
| * 2021 edition: https://tc39.es/ecma262/#sec-json.parse | ||
| * | ||
| * Includes extensions for handling Map and Set objects. | ||
| */ | ||
| function applyReviver(reviver, obj, key, val) { | ||
| if (val && _typeof(val) === 'object') { | ||
| if (Array.isArray(val)) { | ||
| for (var i = 0, len = val.length; i < len; ++i) { | ||
| var v0 = val[i]; | ||
| var v1 = applyReviver(reviver, val, String(i), v0); | ||
| if (v1 === undefined) delete val[i];else if (v1 !== v0) val[i] = v1; | ||
| } | ||
| } else if (val instanceof Map) { | ||
| for (var _i = 0, _Array$from = Array.from(val.keys()); _i < _Array$from.length; _i++) { | ||
| var k = _Array$from[_i]; | ||
| var _v = val.get(k); | ||
| var _v2 = applyReviver(reviver, val, k, _v); | ||
| if (_v2 === undefined) val.delete(k);else if (_v2 !== _v) val.set(k, _v2); | ||
| } | ||
| } else if (val instanceof Set) { | ||
| for (var _i2 = 0, _Array$from2 = Array.from(val); _i2 < _Array$from2.length; _i2++) { | ||
| var _v3 = _Array$from2[_i2]; | ||
| var _v4 = applyReviver(reviver, val, _v3, _v3); | ||
| if (_v4 === undefined) val.delete(_v3);else if (_v4 !== _v3) { | ||
| val.delete(_v3); | ||
| val.add(_v4); | ||
| } | ||
| } | ||
| } else { | ||
| for (var _i3 = 0, _Object$entries = Object.entries(val); _i3 < _Object$entries.length; _i3++) { | ||
| var _Object$entries$_i = _slicedToArray(_Object$entries[_i3], 2), | ||
| _k = _Object$entries$_i[0], | ||
| _v5 = _Object$entries$_i[1]; | ||
| var _v6 = applyReviver(reviver, val, _k, _v5); | ||
| if (_v6 === undefined) delete val[_k];else if (_v6 !== _v5) val[_k] = _v6; | ||
| } | ||
| } | ||
| } | ||
| return reviver.call(obj, key, val); | ||
| } | ||
| 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 resolveTagHandle(doc, node) { | ||
| var _node$tag = node.tag, | ||
| handle = _node$tag.handle, | ||
| suffix = _node$tag.suffix; | ||
| var prefix = doc.tagPrefixes.find(function (p) { | ||
| return p.handle === handle; | ||
| }); | ||
| if (!prefix) { | ||
| var dtp = doc.getDefaults().tagPrefixes; | ||
| if (dtp) prefix = dtp.find(function (p) { | ||
| return p.handle === handle; | ||
| }); | ||
| if (!prefix) throw new YAMLSemanticError(node, "The ".concat(handle, " tag handle is non-default and was not declared.")); | ||
| } | ||
| if (!suffix) throw new YAMLSemanticError(node, "The ".concat(handle, " tag has no suffix.")); | ||
| if (handle === '!' && (doc.version || doc.options.version) === '1.0') { | ||
| if (suffix[0] === '^') { | ||
| doc.warnings.push(new YAMLWarning(node, 'YAML 1.0 ^ tag expansion is not supported')); | ||
| 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); | ||
| } | ||
| function resolveTagName(doc, 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."); | ||
| doc.errors.push(new YAMLSemanticError(node, msg)); | ||
| } else if (handle === '!' && !suffix) { | ||
| nonSpecific = true; | ||
| } else { | ||
| try { | ||
| return resolveTagHandle(doc, node); | ||
| } catch (error) { | ||
| doc.errors.push(error); | ||
| } | ||
| } | ||
| } | ||
| switch (type) { | ||
| case Type.BLOCK_FOLDED: | ||
| case Type.BLOCK_LITERAL: | ||
| case Type.QUOTE_DOUBLE: | ||
| case Type.QUOTE_SINGLE: | ||
| return defaultTags.STR; | ||
| case Type.FLOW_MAP: | ||
| case Type.MAP: | ||
| return defaultTags.MAP; | ||
| case Type.FLOW_SEQ: | ||
| case Type.SEQ: | ||
| return defaultTags.SEQ; | ||
| case Type.PLAIN: | ||
| return nonSpecific ? defaultTags.STR : null; | ||
| default: | ||
| return null; | ||
| } | ||
| } | ||
| function checkFlowCollectionEnd(errors, cst) { | ||
| var char, name; | ||
| switch (cst.type) { | ||
| case Type.FLOW_MAP: | ||
| char = '}'; | ||
| name = 'flow map'; | ||
| break; | ||
| case Type.FLOW_SEQ: | ||
| char = ']'; | ||
| name = 'flow sequence'; | ||
| break; | ||
| default: | ||
| errors.push(new YAMLSemanticError(cst, 'Not a flow collection!?')); | ||
| return; | ||
| } | ||
| var lastItem; | ||
| for (var i = cst.items.length - 1; i >= 0; --i) { | ||
| var item = cst.items[i]; | ||
| if (!item || item.type !== Type.COMMENT) { | ||
| lastItem = item; | ||
| break; | ||
| } | ||
| } | ||
| if (lastItem && lastItem.char !== char) { | ||
| var msg = "Expected ".concat(name, " to end with ").concat(char); | ||
| var err; | ||
| if (typeof lastItem.offset === 'number') { | ||
| err = new YAMLSemanticError(cst, msg); | ||
| err.offset = lastItem.offset + 1; | ||
| } else { | ||
| err = new YAMLSemanticError(lastItem, msg); | ||
| if (lastItem.range && lastItem.range.end) err.offset = lastItem.range.end - lastItem.range.start; | ||
| } | ||
| errors.push(err); | ||
| } | ||
| } | ||
| function checkFlowCommentSpace(errors, comment) { | ||
| var prev = comment.context.src[comment.range.start - 1]; | ||
| if (prev !== '\n' && prev !== '\t' && prev !== ' ') { | ||
| var msg = 'Comments must be separated from other tokens by white space characters'; | ||
| errors.push(new YAMLSemanticError(comment, msg)); | ||
| } | ||
| } | ||
| function getLongKeyError(source, key) { | ||
| var sk = String(key); | ||
| var k = sk.substr(0, 8) + '...' + sk.substr(-8); | ||
| return new YAMLSemanticError(source, "The \"".concat(k, "\" key is too long")); | ||
| } | ||
| function resolveComments(collection, comments) { | ||
| var _iterator = _createForOfIteratorHelper(comments), | ||
| _step; | ||
| try { | ||
| for (_iterator.s(); !(_step = _iterator.n()).done;) { | ||
| var _step$value = _step.value, | ||
| afterKey = _step$value.afterKey, | ||
| before = _step$value.before, | ||
| comment = _step$value.comment; | ||
| var item = collection.items[before]; | ||
| if (!item) { | ||
| if (comment !== undefined) { | ||
| if (collection.comment) collection.comment += '\n' + comment;else collection.comment = comment; | ||
| } | ||
| } else { | ||
| if (afterKey && item.value) item = item.value; | ||
| if (comment === undefined) { | ||
| if (afterKey || !item.commentBefore) item.spaceBefore = true; | ||
| } else { | ||
| if (item.commentBefore) item.commentBefore += '\n' + comment;else item.commentBefore = comment; | ||
| } | ||
| } | ||
| } | ||
| } catch (err) { | ||
| _iterator.e(err); | ||
| } finally { | ||
| _iterator.f(); | ||
| } | ||
| } | ||
| function resolveMap(doc, cst) { | ||
| var _ref = cst.type === Type.FLOW_MAP ? resolveFlowMapItems(doc, cst) : resolveBlockMapItems(doc, cst), | ||
| comments = _ref.comments, | ||
| items = _ref.items; | ||
| var map = new YAMLMap(doc.schema); | ||
| map.items = items; | ||
| resolveComments(map, comments); | ||
| var hasCollectionKey = false; | ||
| for (var i = 0; i < items.length; ++i) { | ||
| var iKey = items[i].key; | ||
| if (iKey instanceof Collection) hasCollectionKey = true; | ||
| if (doc.schema.merge && iKey && iKey.value === MERGE_KEY) { | ||
| items[i] = new Merge(items[i]); | ||
| var sources = items[i].value.items; | ||
| var error = null; | ||
| sources.some(function (node) { | ||
| if (node instanceof Alias) { | ||
| // During parsing, alias sources are CST nodes; to account for | ||
| // circular references their resolved values can't be used here. | ||
| var type = node.source.type; | ||
| if (type === Type.MAP || type === Type.FLOW_MAP) return false; | ||
| return error = 'Merge nodes aliases can only point to maps'; | ||
| } | ||
| return error = 'Merge nodes can only have Alias nodes as values'; | ||
| }); | ||
| if (error) doc.errors.push(new YAMLSemanticError(cst, error)); | ||
| } else { | ||
| for (var j = i + 1; j < items.length; ++j) { | ||
| var jKey = items[j].key; | ||
| if (iKey === jKey || iKey && jKey && Object.prototype.hasOwnProperty.call(iKey, 'value') && iKey.value === jKey.value) { | ||
| var msg = "Map keys must be unique; \"".concat(iKey, "\" is repeated"); | ||
| doc.errors.push(new YAMLSemanticError(cst, msg)); | ||
| break; | ||
| } | ||
| } | ||
| } | ||
| } | ||
| if (hasCollectionKey && !doc.options.mapAsMap) { | ||
| var warn = 'Keys with collection values will be stringified as YAML due to JS Object restrictions. Use mapAsMap: true to avoid this.'; | ||
| doc.warnings.push(new YAMLWarning(cst, warn)); | ||
| } | ||
| cst.resolved = map; | ||
| return map; | ||
| } | ||
| var valueHasPairComment = function valueHasPairComment(_ref2) { | ||
| var _ref2$context = _ref2.context, | ||
| lineStart = _ref2$context.lineStart, | ||
| node = _ref2$context.node, | ||
| src = _ref2$context.src, | ||
| props = _ref2.props; | ||
| if (props.length === 0) return false; | ||
| var start = props[0].start; | ||
| if (node && start > node.valueRange.start) return false; | ||
| if (src[start] !== Char.COMMENT) return false; | ||
| for (var i = lineStart; i < start; ++i) { | ||
| if (src[i] === '\n') return false; | ||
| } | ||
| return true; | ||
| }; | ||
| function resolvePairComment(item, pair) { | ||
| if (!valueHasPairComment(item)) return; | ||
| var comment = item.getPropValue(0, Char.COMMENT, true); | ||
| var found = false; | ||
| var cb = pair.value.commentBefore; | ||
| if (cb && cb.startsWith(comment)) { | ||
| pair.value.commentBefore = cb.substr(comment.length + 1); | ||
| found = true; | ||
| } else { | ||
| var cc = pair.value.comment; | ||
| if (!item.node && cc && cc.startsWith(comment)) { | ||
| pair.value.comment = cc.substr(comment.length + 1); | ||
| found = true; | ||
| } | ||
| } | ||
| if (found) pair.comment = comment; | ||
| } | ||
| function resolveBlockMapItems(doc, cst) { | ||
| var comments = []; | ||
| var items = []; | ||
| var key = undefined; | ||
| var keyStart = null; | ||
| for (var i = 0; i < cst.items.length; ++i) { | ||
| var item = cst.items[i]; | ||
| switch (item.type) { | ||
| case Type.BLANK_LINE: | ||
| comments.push({ | ||
| afterKey: !!key, | ||
| before: items.length | ||
| }); | ||
| break; | ||
| case Type.COMMENT: | ||
| comments.push({ | ||
| afterKey: !!key, | ||
| before: items.length, | ||
| comment: item.comment | ||
| }); | ||
| break; | ||
| case Type.MAP_KEY: | ||
| if (key !== undefined) items.push(new Pair(key)); | ||
| if (item.error) doc.errors.push(item.error); | ||
| key = resolveNode(doc, item.node); | ||
| keyStart = null; | ||
| break; | ||
| case 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 === Type.MAP && !item.node.context.atLineStart) { | ||
| var msg = 'Nested mappings are not allowed in compact mappings'; | ||
| doc.errors.push(new YAMLSemanticError(item.node, msg)); | ||
| } | ||
| var valueNode = item.node; | ||
| if (!valueNode && item.props.length > 0) { | ||
| // Comments on an empty mapping value need to be preserved, so we | ||
| // need to construct a minimal empty node here to use instead of the | ||
| // missing `item.node`. -- eemeli/yaml#19 | ||
| valueNode = new PlainValue(Type.PLAIN, []); | ||
| valueNode.context = { | ||
| parent: item, | ||
| src: item.context.src | ||
| }; | ||
| var pos = item.range.start + 1; | ||
| valueNode.range = { | ||
| start: pos, | ||
| end: pos | ||
| }; | ||
| valueNode.valueRange = { | ||
| start: pos, | ||
| end: pos | ||
| }; | ||
| if (typeof item.range.origStart === 'number') { | ||
| var origPos = item.range.origStart + 1; | ||
| valueNode.range.origStart = valueNode.range.origEnd = origPos; | ||
| valueNode.valueRange.origStart = valueNode.valueRange.origEnd = origPos; | ||
| } | ||
| } | ||
| var pair = new Pair(key, resolveNode(doc, valueNode)); | ||
| resolvePairComment(item, pair); | ||
| items.push(pair); | ||
| if (key && typeof keyStart === 'number') { | ||
| if (item.range.start > keyStart + 1024) doc.errors.push(getLongKeyError(cst, key)); | ||
| } | ||
| key = undefined; | ||
| keyStart = null; | ||
| } | ||
| break; | ||
| default: | ||
| if (key !== undefined) items.push(new Pair(key)); | ||
| key = resolveNode(doc, item); | ||
| keyStart = item.range.start; | ||
| if (item.error) doc.errors.push(item.error); | ||
| next: for (var j = i + 1;; ++j) { | ||
| var nextItem = cst.items[j]; | ||
| switch (nextItem && nextItem.type) { | ||
| case Type.BLANK_LINE: | ||
| case Type.COMMENT: | ||
| continue next; | ||
| case Type.MAP_VALUE: | ||
| break next; | ||
| default: | ||
| { | ||
| var _msg = 'Implicit map keys need to be followed by map values'; | ||
| doc.errors.push(new YAMLSemanticError(item, _msg)); | ||
| break next; | ||
| } | ||
| } | ||
| } | ||
| if (item.valueRangeContainsNewline) { | ||
| var _msg2 = 'Implicit map keys need to be on a single line'; | ||
| doc.errors.push(new YAMLSemanticError(item, _msg2)); | ||
| } | ||
| } | ||
| } | ||
| if (key !== undefined) items.push(new Pair(key)); | ||
| return { | ||
| comments: comments, | ||
| items: items | ||
| }; | ||
| } | ||
| function resolveFlowMapItems(doc, cst) { | ||
| var comments = []; | ||
| var items = []; | ||
| var key = undefined; | ||
| var explicitKey = false; | ||
| var next = '{'; | ||
| for (var i = 0; i < cst.items.length; ++i) { | ||
| var item = cst.items[i]; | ||
| if (typeof item.char === 'string') { | ||
| var char = item.char, | ||
| offset = item.offset; | ||
| if (char === '?' && key === undefined && !explicitKey) { | ||
| explicitKey = true; | ||
| next = ':'; | ||
| continue; | ||
| } | ||
| if (char === ':') { | ||
| if (key === undefined) key = null; | ||
| if (next === ':') { | ||
| next = ','; | ||
| continue; | ||
| } | ||
| } else { | ||
| if (explicitKey) { | ||
| if (key === undefined && char !== ',') key = null; | ||
| explicitKey = false; | ||
| } | ||
| if (key !== undefined) { | ||
| items.push(new Pair(key)); | ||
| key = undefined; | ||
| if (char === ',') { | ||
| next = ':'; | ||
| continue; | ||
| } | ||
| } | ||
| } | ||
| if (char === '}') { | ||
| if (i === cst.items.length - 1) continue; | ||
| } else if (char === next) { | ||
| next = ':'; | ||
| continue; | ||
| } | ||
| var msg = "Flow map contains an unexpected ".concat(char); | ||
| var err = new YAMLSyntaxError(cst, msg); | ||
| err.offset = offset; | ||
| doc.errors.push(err); | ||
| } else if (item.type === Type.BLANK_LINE) { | ||
| comments.push({ | ||
| afterKey: !!key, | ||
| before: items.length | ||
| }); | ||
| } else if (item.type === Type.COMMENT) { | ||
| checkFlowCommentSpace(doc.errors, item); | ||
| comments.push({ | ||
| afterKey: !!key, | ||
| before: items.length, | ||
| comment: item.comment | ||
| }); | ||
| } else if (key === undefined) { | ||
| if (next === ',') doc.errors.push(new YAMLSemanticError(item, 'Separator , missing in flow map')); | ||
| key = resolveNode(doc, item); | ||
| } else { | ||
| if (next !== ',') doc.errors.push(new YAMLSemanticError(item, 'Indicator : missing in flow map entry')); | ||
| items.push(new Pair(key, resolveNode(doc, item))); | ||
| key = undefined; | ||
| explicitKey = false; | ||
| } | ||
| } | ||
| checkFlowCollectionEnd(doc.errors, cst); | ||
| if (key !== undefined) items.push(new Pair(key)); | ||
| return { | ||
| comments: comments, | ||
| items: items | ||
| }; | ||
| } | ||
| function resolveSeq(doc, cst) { | ||
| var _ref = cst.type === Type.FLOW_SEQ ? resolveFlowSeqItems(doc, cst) : resolveBlockSeqItems(doc, cst), | ||
| comments = _ref.comments, | ||
| items = _ref.items; | ||
| var seq = new YAMLSeq(doc.schema); | ||
| seq.items = items; | ||
| resolveComments(seq, comments); | ||
| if (!doc.options.mapAsMap && items.some(function (it) { | ||
| return it instanceof Pair && it.key instanceof Collection; | ||
| })) { | ||
| var warn = 'Keys with collection values will be stringified as YAML due to JS Object restrictions. Use mapAsMap: true to avoid this.'; | ||
| doc.warnings.push(new YAMLWarning(cst, warn)); | ||
| } | ||
| cst.resolved = seq; | ||
| return seq; | ||
| } | ||
| function resolveBlockSeqItems(doc, cst) { | ||
| var comments = []; | ||
| var items = []; | ||
| for (var i = 0; i < cst.items.length; ++i) { | ||
| var item = cst.items[i]; | ||
| switch (item.type) { | ||
| case Type.BLANK_LINE: | ||
| comments.push({ | ||
| before: items.length | ||
| }); | ||
| break; | ||
| case Type.COMMENT: | ||
| comments.push({ | ||
| comment: item.comment, | ||
| before: items.length | ||
| }); | ||
| break; | ||
| case Type.SEQ_ITEM: | ||
| if (item.error) doc.errors.push(item.error); | ||
| items.push(resolveNode(doc, item.node)); | ||
| if (item.hasProps) { | ||
| var msg = 'Sequence items cannot have tags or anchors before the - indicator'; | ||
| doc.errors.push(new YAMLSemanticError(item, msg)); | ||
| } | ||
| break; | ||
| default: | ||
| if (item.error) doc.errors.push(item.error); | ||
| doc.errors.push(new YAMLSyntaxError(item, "Unexpected ".concat(item.type, " node in sequence"))); | ||
| } | ||
| } | ||
| return { | ||
| comments: comments, | ||
| items: items | ||
| }; | ||
| } | ||
| function resolveFlowSeqItems(doc, cst) { | ||
| var comments = []; | ||
| var items = []; | ||
| var explicitKey = false; | ||
| var key = undefined; | ||
| var keyStart = null; | ||
| var next = '['; | ||
| var prevItem = null; | ||
| for (var i = 0; i < cst.items.length; ++i) { | ||
| var item = cst.items[i]; | ||
| if (typeof item.char === 'string') { | ||
| var char = item.char, | ||
| offset = item.offset; | ||
| if (char !== ':' && (explicitKey || key !== undefined)) { | ||
| if (explicitKey && key === undefined) key = next ? items.pop() : null; | ||
| items.push(new Pair(key)); | ||
| explicitKey = false; | ||
| key = undefined; | ||
| keyStart = null; | ||
| } | ||
| if (char === next) { | ||
| next = null; | ||
| } else if (!next && char === '?') { | ||
| explicitKey = true; | ||
| } else if (next !== '[' && char === ':' && key === undefined) { | ||
| if (next === ',') { | ||
| key = items.pop(); | ||
| if (key instanceof Pair) { | ||
| var msg = 'Chaining flow sequence pairs is invalid'; | ||
| var err = new YAMLSemanticError(cst, msg); | ||
| err.offset = offset; | ||
| doc.errors.push(err); | ||
| } | ||
| if (!explicitKey && typeof keyStart === 'number') { | ||
| var keyEnd = item.range ? item.range.start : item.offset; | ||
| if (keyEnd > keyStart + 1024) doc.errors.push(getLongKeyError(cst, key)); | ||
| var src = prevItem.context.src; | ||
| for (var _i = keyStart; _i < keyEnd; ++_i) { | ||
| if (src[_i] === '\n') { | ||
| var _msg = 'Implicit keys of flow sequence pairs need to be on a single line'; | ||
| doc.errors.push(new YAMLSemanticError(prevItem, _msg)); | ||
| break; | ||
| } | ||
| } | ||
| } | ||
| } else { | ||
| key = null; | ||
| } | ||
| keyStart = null; | ||
| explicitKey = false; | ||
| next = null; | ||
| } else if (next === '[' || char !== ']' || i < cst.items.length - 1) { | ||
| var _msg2 = "Flow sequence contains an unexpected ".concat(char); | ||
| var _err = new YAMLSyntaxError(cst, _msg2); | ||
| _err.offset = offset; | ||
| doc.errors.push(_err); | ||
| } | ||
| } else if (item.type === Type.BLANK_LINE) { | ||
| comments.push({ | ||
| before: items.length | ||
| }); | ||
| } else if (item.type === Type.COMMENT) { | ||
| checkFlowCommentSpace(doc.errors, item); | ||
| comments.push({ | ||
| comment: item.comment, | ||
| before: items.length | ||
| }); | ||
| } else { | ||
| if (next) { | ||
| var _msg3 = "Expected a ".concat(next, " in flow sequence"); | ||
| doc.errors.push(new YAMLSemanticError(item, _msg3)); | ||
| } | ||
| var value = resolveNode(doc, item); | ||
| if (key === undefined) { | ||
| items.push(value); | ||
| prevItem = item; | ||
| } else { | ||
| items.push(new Pair(key, value)); | ||
| key = undefined; | ||
| } | ||
| keyStart = item.range.start; | ||
| next = ','; | ||
| } | ||
| } | ||
| checkFlowCollectionEnd(doc.errors, cst); | ||
| if (key !== undefined) items.push(new Pair(key)); | ||
| return { | ||
| comments: comments, | ||
| items: items | ||
| }; | ||
| } | ||
| function resolveByTagName(_ref, tagName, value, onError) { | ||
| var knownTags = _ref.knownTags, | ||
| tags = _ref.tags; | ||
| var matchWithTest = []; | ||
| var _iterator = _createForOfIteratorHelper(tags), | ||
| _step; | ||
| try { | ||
| for (_iterator.s(); !(_step = _iterator.n()).done;) { | ||
| var tag = _step.value; | ||
| if (tag.tag === tagName) { | ||
| if (tag.test) { | ||
| if (typeof value === 'string') matchWithTest.push(tag);else onError("The tag ".concat(tagName, " cannot be applied to a collection")); | ||
| } else { | ||
| var _res = tag.resolve(value, onError); | ||
| return _res instanceof Collection ? _res : new Scalar(_res); | ||
| } | ||
| } | ||
| } | ||
| } catch (err) { | ||
| _iterator.e(err); | ||
| } finally { | ||
| _iterator.f(); | ||
| } | ||
| if (matchWithTest.length > 0) return resolveScalar(value, matchWithTest); | ||
| var kt = knownTags[tagName]; | ||
| if (kt) { | ||
| tags.push(Object.assign({}, kt, { | ||
| default: false, | ||
| test: undefined | ||
| })); | ||
| var res = kt.resolve(value, onError); | ||
| return res instanceof Collection ? res : new Scalar(res); | ||
| } | ||
| return null; | ||
| } | ||
| function resolveTag(doc, node, tagName) { | ||
| var MAP = defaultTags.MAP, | ||
| SEQ = defaultTags.SEQ, | ||
| STR = defaultTags.STR; | ||
| var value, fallback; | ||
| var onError = function onError(message) { | ||
| return doc.errors.push(new YAMLSemanticError(node, message)); | ||
| }; | ||
| try { | ||
| switch (node.type) { | ||
| case Type.FLOW_MAP: | ||
| case Type.MAP: | ||
| value = resolveMap(doc, node); | ||
| fallback = MAP; | ||
| if (tagName === SEQ || tagName === STR) onError("The tag ".concat(tagName, " cannot be applied to a mapping")); | ||
| break; | ||
| case Type.FLOW_SEQ: | ||
| case Type.SEQ: | ||
| value = resolveSeq(doc, node); | ||
| fallback = SEQ; | ||
| if (tagName === MAP || tagName === STR) onError("The tag ".concat(tagName, " cannot be applied to a sequence")); | ||
| break; | ||
| default: | ||
| value = node.strValue || ''; | ||
| if (typeof value !== 'string') { | ||
| value.errors.forEach(function (error) { | ||
| return doc.errors.push(error); | ||
| }); | ||
| value = value.str; | ||
| } | ||
| if (tagName === MAP || tagName === SEQ) onError("The tag ".concat(tagName, " cannot be applied to a scalar")); | ||
| fallback = STR; | ||
| } | ||
| var res = resolveByTagName(doc.schema, tagName, value, onError); | ||
| if (res) { | ||
| if (tagName && node.tag) res.tag = tagName; | ||
| return res; | ||
| } | ||
| } catch (error) { | ||
| /* istanbul ignore if */ | ||
| if (!error.source) error.source = node; | ||
| doc.errors.push(error); | ||
| return null; | ||
| } | ||
| try { | ||
| if (!fallback) throw new Error("The tag ".concat(tagName, " is unavailable")); | ||
| var msg = "The tag ".concat(tagName, " is unavailable, falling back to ").concat(fallback); | ||
| doc.warnings.push(new YAMLWarning(node, msg)); | ||
| var _res2 = resolveByTagName(doc.schema, fallback, value, onError); | ||
| _res2.tag = tagName; | ||
| return _res2; | ||
| } catch (error) { | ||
| var refError = new YAMLReferenceError(node, error.message); | ||
| refError.stack = error.stack; | ||
| doc.errors.push(refError); | ||
| return null; | ||
| } | ||
| } | ||
| var isCollectionItem = function isCollectionItem(node) { | ||
| if (!node) return false; | ||
| var type = node.type; | ||
| return type === Type.MAP_KEY || type === Type.MAP_VALUE || type === Type.SEQ_ITEM; | ||
| }; | ||
| function resolveNodeProps(errors, node) { | ||
| var comments = { | ||
| before: [], | ||
| after: [] | ||
| }; | ||
| var hasAnchor = false; | ||
| var hasTag = false; | ||
| var props = isCollectionItem(node.context.parent) ? node.context.parent.props.concat(node.props) : node.props; | ||
| var _iterator = _createForOfIteratorHelper(props), | ||
| _step; | ||
| try { | ||
| for (_iterator.s(); !(_step = _iterator.n()).done;) { | ||
| var _step$value = _step.value, | ||
| start = _step$value.start, | ||
| end = _step$value.end; | ||
| switch (node.context.src[start]) { | ||
| case Char.COMMENT: | ||
| { | ||
| if (!node.commentHasRequiredWhitespace(start)) { | ||
| var msg = 'Comments must be separated from other tokens by white space characters'; | ||
| errors.push(new YAMLSemanticError(node, msg)); | ||
| } | ||
| var header = node.header, | ||
| valueRange = node.valueRange; | ||
| var cc = valueRange && (start > valueRange.start || header && start > header.start) ? comments.after : comments.before; | ||
| cc.push(node.context.src.slice(start + 1, end)); | ||
| break; | ||
| } | ||
| // Actual anchor & tag resolution is handled by schema, here we just complain | ||
| case Char.ANCHOR: | ||
| if (hasAnchor) { | ||
| var _msg = 'A node can have at most one anchor'; | ||
| errors.push(new YAMLSemanticError(node, _msg)); | ||
| } | ||
| hasAnchor = true; | ||
| break; | ||
| case Char.TAG: | ||
| if (hasTag) { | ||
| var _msg2 = 'A node can have at most one tag'; | ||
| errors.push(new YAMLSemanticError(node, _msg2)); | ||
| } | ||
| hasTag = true; | ||
| break; | ||
| } | ||
| } | ||
| } catch (err) { | ||
| _iterator.e(err); | ||
| } finally { | ||
| _iterator.f(); | ||
| } | ||
| return { | ||
| comments: comments, | ||
| hasAnchor: hasAnchor, | ||
| hasTag: hasTag | ||
| }; | ||
| } | ||
| function resolveNodeValue(doc, node) { | ||
| var anchors = doc.anchors, | ||
| errors = doc.errors, | ||
| schema = doc.schema; | ||
| if (node.type === Type.ALIAS) { | ||
| var name = node.rawValue; | ||
| var src = anchors.getNode(name); | ||
| if (!src) { | ||
| var msg = "Aliased anchor not found: ".concat(name); | ||
| errors.push(new YAMLReferenceError(node, msg)); | ||
| return null; | ||
| } // Lazy resolution for circular references | ||
| var res = new Alias(src); | ||
| anchors._cstAliases.push(res); | ||
| return res; | ||
| } | ||
| var tagName = resolveTagName(doc, node); | ||
| if (tagName) return resolveTag(doc, node, tagName); | ||
| if (node.type !== Type.PLAIN) { | ||
| var _msg3 = "Failed to resolve ".concat(node.type, " node here"); | ||
| errors.push(new YAMLSyntaxError(node, _msg3)); | ||
| return null; | ||
| } | ||
| try { | ||
| var str = node.strValue || ''; | ||
| if (typeof str !== 'string') { | ||
| str.errors.forEach(function (error) { | ||
| return doc.errors.push(error); | ||
| }); | ||
| str = str.str; | ||
| } | ||
| return resolveScalar(str, schema.tags); | ||
| } catch (error) { | ||
| if (!error.source) error.source = node; | ||
| errors.push(error); | ||
| return null; | ||
| } | ||
| } // sets node.resolved on success | ||
| function resolveNode(doc, node) { | ||
| if (!node) return null; | ||
| if (node.error) doc.errors.push(node.error); | ||
| var _resolveNodeProps = resolveNodeProps(doc.errors, node), | ||
| comments = _resolveNodeProps.comments, | ||
| hasAnchor = _resolveNodeProps.hasAnchor, | ||
| hasTag = _resolveNodeProps.hasTag; | ||
| if (hasAnchor) { | ||
| var anchors = doc.anchors; | ||
| 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; | ||
| } | ||
| if (node.type === Type.ALIAS && (hasAnchor || hasTag)) { | ||
| var msg = 'An alias node must not specify any properties'; | ||
| doc.errors.push(new YAMLSemanticError(node, msg)); | ||
| } | ||
| var res = resolveNodeValue(doc, node); | ||
| if (res) { | ||
| res.range = [node.range.start, node.range.end]; | ||
| if (doc.options.keepCstNodes) res.cstNode = node; | ||
| if (doc.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; | ||
| } | ||
| 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(value, replacer, options) { | ||
| _classCallCheck(this, Document); | ||
| if (options === undefined && replacer && _typeof(replacer) === 'object' && !Array.isArray(replacer)) { | ||
| options = replacer; | ||
| replacer = undefined; | ||
| } | ||
| this.options = Object.assign({}, defaultOptions, options); | ||
| this.anchors = new Anchors(this.options.anchorPrefix); | ||
| this.commentBefore = null; | ||
| this.comment = null; | ||
| this.directivesEndMarker = null; | ||
| this.errors = []; | ||
| this.schema = null; | ||
| this.tagPrefixes = []; | ||
| this.version = null; | ||
| this.warnings = []; | ||
| if (value === undefined) { | ||
| // note that this.schema is left as null here | ||
| this.contents = null; | ||
| } else if (value instanceof Document$1) { | ||
| this.parse(value); | ||
| } else { | ||
| this.contents = this.createNode(value, { | ||
| replacer: replacer | ||
| }); | ||
| } | ||
| } | ||
| _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: "createNode", | ||
| value: function createNode$1(value) { | ||
| var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, | ||
| keepUndefined = _ref.keepUndefined, | ||
| onTagObj = _ref.onTagObj, | ||
| replacer = _ref.replacer, | ||
| tag = _ref.tag, | ||
| wrapScalars = _ref.wrapScalars; | ||
| this.setSchema(); | ||
| if (typeof replacer === 'function') value = replacer.call({ | ||
| '': value | ||
| }, '', value);else if (Array.isArray(replacer)) { | ||
| var keyToStr = function keyToStr(v) { | ||
| return typeof v === 'number' || v instanceof String || v instanceof Number; | ||
| }; | ||
| var asStr = replacer.filter(keyToStr).map(String); | ||
| if (asStr.length > 0) replacer = replacer.concat(asStr); | ||
| } | ||
| if (typeof keepUndefined !== 'boolean') keepUndefined = !!this.options.keepUndefined; | ||
| var aliasNodes = []; | ||
| var ctx = { | ||
| keepUndefined: keepUndefined, | ||
| onAlias: function onAlias(source) { | ||
| var alias = new Alias(source); | ||
| aliasNodes.push(alias); | ||
| return alias; | ||
| }, | ||
| onTagObj: onTagObj, | ||
| prevObjects: new Map(), | ||
| replacer: replacer, | ||
| schema: this.schema, | ||
| wrapScalars: wrapScalars !== false | ||
| }; | ||
| var node = createNode(value, tag, ctx); | ||
| for (var _i = 0, _aliasNodes = aliasNodes; _i < _aliasNodes.length; _i++) { | ||
| var alias = _aliasNodes[_i]; | ||
| // With circular references, the source node is only resolved after all of | ||
| // its child nodes are. This is why anchors are set only after all of the | ||
| // nodes have been created. | ||
| alias.source = alias.source.node; | ||
| var name = this.anchors.getName(alias.source); | ||
| if (!name) { | ||
| name = this.anchors.newName(); | ||
| this.anchors.map[name] = alias.source; | ||
| } | ||
| } | ||
| return node; | ||
| } | ||
| }, { | ||
| key: "createPair", | ||
| value: function createPair(key, value) { | ||
| var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; | ||
| var k = this.createNode(key, options); | ||
| var v = this.createNode(value, options); | ||
| return new Pair(k, v); | ||
| } | ||
| }, { | ||
| 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) { | ||
| if (this.contents == null) { | ||
| this.setSchema(); | ||
| this.contents = collectionFromPath(this.schema, [key], value); | ||
| } else { | ||
| assertCollection(this.contents); | ||
| this.contents.set(key, value); | ||
| } | ||
| } | ||
| }, { | ||
| key: "setIn", | ||
| value: function setIn(path, value) { | ||
| if (isEmptyPath(path)) this.contents = value;else if (this.contents == null) { | ||
| this.setSchema(); | ||
| this.contents = collectionFromPath(this.schema, path, 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(defaultTagPrefix) !== 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: "toJS", | ||
| value: function toJS$1() { | ||
| var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, | ||
| json = _ref2.json, | ||
| jsonArg = _ref2.jsonArg, | ||
| mapAsMap = _ref2.mapAsMap, | ||
| onAnchor = _ref2.onAnchor, | ||
| reviver = _ref2.reviver; | ||
| var anchorNodes = Object.values(this.anchors.map).map(function (node) { | ||
| return [node, { | ||
| alias: [], | ||
| aliasCount: 0, | ||
| count: 1 | ||
| }]; | ||
| }); | ||
| var anchors = anchorNodes.length > 0 ? new Map(anchorNodes) : null; | ||
| var ctx = { | ||
| anchors: anchors, | ||
| doc: this, | ||
| indentStep: ' ', | ||
| keep: !json, | ||
| mapAsMap: typeof mapAsMap === 'boolean' ? mapAsMap : !!this.options.mapAsMap, | ||
| maxAliasCount: this.options.maxAliasCount, | ||
| stringify: stringify // Requiring directly in Pair would create circular dependencies | ||
| }; | ||
| var res = toJS(this.contents, jsonArg || '', ctx); | ||
| if (typeof onAnchor === 'function' && anchors) { | ||
| var _iterator3 = _createForOfIteratorHelper(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 typeof reviver === 'function' ? applyReviver(reviver, { | ||
| '': res | ||
| }, '', res) : res; | ||
| } | ||
| }, { | ||
| key: "toJSON", | ||
| value: function toJSON(jsonArg, onAnchor) { | ||
| return this.toJS({ | ||
| json: true, | ||
| jsonArg: jsonArg, | ||
| mapAsMap: false, | ||
| onAnchor: onAnchor | ||
| }); | ||
| } | ||
| }, { | ||
| 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 (_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 || this.directivesEndMarker) lines.push('---'); | ||
| if (this.commentBefore) { | ||
| if (hasDirectives || !this.directivesEndMarker) lines.unshift(''); | ||
| lines.unshift(this.commentBefore.replace(/^/gm, '#')); | ||
| } | ||
| var ctx = { | ||
| anchors: Object.create(null), | ||
| 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 { | ||
| 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); | ||
| /* global console, process, YAML_SILENCE_WARNINGS */ | ||
| function warn(warning, type) { | ||
| if (typeof YAML_SILENCE_WARNINGS !== 'undefined' && YAML_SILENCE_WARNINGS) return; | ||
| if (typeof process !== 'undefined') { | ||
| if (process.env.YAML_SILENCE_WARNINGS) return; // This will throw in Jest if `warning` is an Error instance due to | ||
| // https://github.com/facebook/jest/issues/2549 | ||
| if (process.emitWarning) { | ||
| process.emitWarning(warning, type); | ||
| return; | ||
| } | ||
| } // eslint-disable-next-line no-console | ||
| console.warn(type ? "".concat(type, ": ").concat(warning) : warning); | ||
| } | ||
| function parseAllDocuments(src, options) { | ||
| var stream = []; | ||
| var prev; | ||
| const stream = []; | ||
| let prev; | ||
| var _iterator = _createForOfIteratorHelper(parse$1(src)), | ||
| _step; | ||
| try { | ||
| for (_iterator.s(); !(_step = _iterator.n()).done;) { | ||
| var cstDoc = _step.value; | ||
| var doc = new Document(undefined, null, options); | ||
| doc.parse(cstDoc, prev); | ||
| stream.push(doc); | ||
| prev = doc; | ||
| } | ||
| } catch (err) { | ||
| _iterator.e(err); | ||
| } finally { | ||
| _iterator.f(); | ||
| for (const cstDoc of parse$1(src)) { | ||
| const doc = new Document(undefined, null, options); | ||
| doc.parse(cstDoc, prev); | ||
| stream.push(doc); | ||
| prev = doc; | ||
| } | ||
@@ -2010,7 +25,7 @@ | ||
| function parseDocument(src, options) { | ||
| var cst = parse$1(src); | ||
| var doc = new Document(cst[0], null, options); | ||
| const cst = parse$1(src); | ||
| const doc = new Document(cst[0], null, options); | ||
| if (cst.length > 1) { | ||
| var errMsg = 'Source contains multiple documents; please use YAML.parseAllDocuments()'; | ||
| if (cst.length > 1 && LogLevel.indexOf(doc.options.logLevel) >= LogLevel.ERROR) { | ||
| const errMsg = 'Source contains multiple documents; please use YAML.parseAllDocuments()'; | ||
| doc.errors.unshift(new YAMLSemanticError(cst[1], errMsg)); | ||
@@ -2022,3 +37,3 @@ } | ||
| function parse(src, reviver, options) { | ||
| if (options === undefined && reviver && _typeof(reviver) === 'object') { | ||
| if (options === undefined && reviver && typeof reviver === 'object') { | ||
| options = reviver; | ||
@@ -2028,20 +43,22 @@ reviver = undefined; | ||
| var doc = parseDocument(src, options); | ||
| doc.warnings.forEach(function (warning) { | ||
| return warn(warning); | ||
| }); | ||
| if (doc.errors.length > 0) throw doc.errors[0]; | ||
| const doc = parseDocument(src, options); | ||
| doc.warnings.forEach(warning => warn(doc.options.logLevel, warning)); | ||
| if (doc.errors.length > 0) { | ||
| if (LogLevel.indexOf(doc.options.logLevel) >= LogLevel.ERROR) throw doc.errors[0];else doc.errors = []; | ||
| } | ||
| return doc.toJS({ | ||
| reviver: reviver | ||
| reviver | ||
| }); | ||
| } | ||
| function stringify$1(value, replacer, options) { | ||
| function stringify(value, replacer, options) { | ||
| if (typeof options === 'string') options = options.length; | ||
| if (typeof options === 'number') { | ||
| var indent = Math.round(options); | ||
| const indent = Math.round(options); | ||
| options = indent < 1 ? undefined : indent > 8 ? { | ||
| indent: 8 | ||
| } : { | ||
| indent: indent | ||
| indent | ||
| }; | ||
@@ -2051,5 +68,5 @@ } | ||
| if (value === undefined) { | ||
| var _ref = options || replacer || {}, | ||
| keepUndefined = _ref.keepUndefined; | ||
| const { | ||
| keepUndefined | ||
| } = options || replacer || {}; | ||
| if (!keepUndefined) return undefined; | ||
@@ -2061,2 +78,2 @@ } | ||
| export { Document, defaultOptions, parse, parseAllDocuments, parseDocument, scalarOptions, stringify$1 as stringify }; | ||
| export { parse, parseAllDocuments, parseDocument, stringify }; |
@@ -1,3 +0,10 @@ | ||
| import './errors-2634d01a.js'; | ||
| export { A as Alias, C as Collection, N as Node, P as Pair, S as Scalar, d as YAMLMap, Y as YAMLSeq, b as binaryOptions, a as boolOptions, i as intOptions, n as nullOptions, s as strOptions } from './stringifyNumber-d8af95b1.js'; | ||
| export { M as Merge, S as Schema } from './Schema-ea978338.js'; | ||
| export { binaryOptions, boolOptions, intOptions, nullOptions, strOptions } from './tags/options.js'; | ||
| export { Schema } from './doc/Schema.js'; | ||
| export { Alias } from './ast/Alias.js'; | ||
| export { Collection } from './ast/Collection.js'; | ||
| export { Merge } from './ast/Merge.js'; | ||
| export { Node } from './ast/Node.js'; | ||
| export { Pair } from './ast/Pair.js'; | ||
| export { Scalar } from './ast/Scalar.js'; | ||
| export { YAMLMap } from './ast/YAMLMap.js'; | ||
| export { YAMLSeq } from './ast/YAMLSeq.js'; |
@@ -1,2 +0,6 @@ | ||
| export { T as Type, k as YAMLError, j as YAMLReferenceError, Y as YAMLSemanticError, i as YAMLSyntaxError, g as YAMLWarning } from './errors-2634d01a.js'; | ||
| export { l as findPair, k as stringifyNumber, c as stringifyString, t as toJS } from './stringifyNumber-d8af95b1.js'; | ||
| export { stringifyNumber } from './stringify/stringifyNumber.js'; | ||
| export { stringifyString } from './stringify/stringifyString.js'; | ||
| export { Type } from './constants.js'; | ||
| export { YAMLError, YAMLReferenceError, YAMLSemanticError, YAMLSyntaxError, YAMLWarning } from './errors.js'; | ||
| export { findPair } from './ast/YAMLMap.js'; | ||
| export { toJS } from './ast/toJS.js'; |
@@ -1,1 +0,2 @@ | ||
| module.exports = require('./dist') | ||
| export * as default from './dist/index.js' | ||
| export * from './dist/index.js' |
| 'use strict'; | ||
| var _rollupPluginBabelHelpers = require('./_rollupPluginBabelHelpers-eed30217.js'); | ||
| var parseCst = require('./parse-3997f544.js'); | ||
| require('./stringifyNumber-dea1120c.js'); | ||
| require('./Schema-807430ba.js'); | ||
| var Document = require('./Document-f89a2614.js'); | ||
| var constants = require('./constants.js'); | ||
| var parse$1 = require('./cst/parse.js'); | ||
| var Document = require('./doc/Document.js'); | ||
| var errors = require('./errors.js'); | ||
| var log = require('./log.js'); | ||
| var options = require('./options.js'); | ||
| var visit = require('./ast/visit.js'); | ||
| /* global console, process, YAML_SILENCE_WARNINGS */ | ||
| function warn(warning, type) { | ||
| if (typeof YAML_SILENCE_WARNINGS !== 'undefined' && YAML_SILENCE_WARNINGS) return; | ||
| if (typeof process !== 'undefined') { | ||
| if (process.env.YAML_SILENCE_WARNINGS) return; // This will throw in Jest if `warning` is an Error instance due to | ||
| // https://github.com/facebook/jest/issues/2549 | ||
| if (process.emitWarning) { | ||
| process.emitWarning(warning, type); | ||
| return; | ||
| } | ||
| } // eslint-disable-next-line no-console | ||
| console.warn(type ? `${type}: ${warning}` : warning); | ||
| } | ||
| function parseAllDocuments(src, options) { | ||
@@ -31,3 +15,3 @@ const stream = []; | ||
| for (const cstDoc of parseCst.parse(src)) { | ||
| for (const cstDoc of parse$1.parse(src)) { | ||
| const doc = new Document.Document(undefined, null, options); | ||
@@ -42,8 +26,8 @@ doc.parse(cstDoc, prev); | ||
| function parseDocument(src, options) { | ||
| const cst = parseCst.parse(src); | ||
| const cst = parse$1.parse(src); | ||
| const doc = new Document.Document(cst[0], null, options); | ||
| if (cst.length > 1) { | ||
| if (cst.length > 1 && constants.LogLevel.indexOf(doc.options.logLevel) >= constants.LogLevel.ERROR) { | ||
| const errMsg = 'Source contains multiple documents; please use YAML.parseAllDocuments()'; | ||
| doc.errors.unshift(new _rollupPluginBabelHelpers.YAMLSemanticError(cst[1], errMsg)); | ||
| doc.errors.unshift(new errors.YAMLSemanticError(cst[1], errMsg)); | ||
| } | ||
@@ -60,4 +44,8 @@ | ||
| const doc = parseDocument(src, options); | ||
| doc.warnings.forEach(warning => warn(warning)); | ||
| if (doc.errors.length > 0) throw doc.errors[0]; | ||
| doc.warnings.forEach(warning => log.warn(doc.options.logLevel, warning)); | ||
| if (doc.errors.length > 0) { | ||
| if (constants.LogLevel.indexOf(doc.options.logLevel) >= constants.LogLevel.ERROR) throw doc.errors[0];else doc.errors = []; | ||
| } | ||
| return doc.toJS({ | ||
@@ -89,6 +77,7 @@ reviver | ||
| exports.parseCST = parseCst.parse; | ||
| exports.parseCST = parse$1.parse; | ||
| exports.Document = Document.Document; | ||
| exports.defaultOptions = Document.defaultOptions; | ||
| exports.scalarOptions = Document.scalarOptions; | ||
| exports.defaultOptions = options.defaultOptions; | ||
| exports.scalarOptions = options.scalarOptions; | ||
| exports.visit = visit.visit; | ||
| exports.parse = parse; | ||
@@ -95,0 +84,0 @@ exports.parseAllDocuments = parseAllDocuments; |
| 'use strict'; | ||
| require('./_rollupPluginBabelHelpers-eed30217.js'); | ||
| var parseCst = require('./parse-3997f544.js'); | ||
| require('./stringifyNumber-dea1120c.js'); | ||
| require('./Schema-807430ba.js'); | ||
| var Document = require('./Document-f89a2614.js'); | ||
| var parse = require('./cst/parse.js'); | ||
| var Document = require('./doc/Document.js'); | ||
@@ -15,3 +12,3 @@ function testEvents(src, options) { | ||
| }, options); | ||
| const docs = parseCst.parse(src).map(cstDoc => new Document.Document(null, opt).parse(cstDoc)); | ||
| const docs = parse.parse(src).map(cstDoc => new Document.Document(null, opt).parse(cstDoc)); | ||
| const errDoc = docs.find(doc => doc.errors.length > 0); | ||
@@ -18,0 +15,0 @@ const error = errDoc ? errDoc.errors[0].message : null; |
| 'use strict'; | ||
| require('./_rollupPluginBabelHelpers-eed30217.js'); | ||
| var stringifyNumber = require('./stringifyNumber-dea1120c.js'); | ||
| var Schema = require('./Schema-807430ba.js'); | ||
| var options = require('./tags/options.js'); | ||
| var Schema = require('./doc/Schema.js'); | ||
| var Alias = require('./ast/Alias.js'); | ||
| var Collection = require('./ast/Collection.js'); | ||
| var Merge = require('./ast/Merge.js'); | ||
| var Node = require('./ast/Node.js'); | ||
| var Pair = require('./ast/Pair.js'); | ||
| var Scalar = require('./ast/Scalar.js'); | ||
| var YAMLMap = require('./ast/YAMLMap.js'); | ||
| var YAMLSeq = require('./ast/YAMLSeq.js'); | ||
| exports.Alias = stringifyNumber.Alias; | ||
| exports.Collection = stringifyNumber.Collection; | ||
| exports.Node = stringifyNumber.Node; | ||
| exports.Pair = stringifyNumber.Pair; | ||
| exports.Scalar = stringifyNumber.Scalar; | ||
| exports.YAMLMap = stringifyNumber.YAMLMap; | ||
| exports.YAMLSeq = stringifyNumber.YAMLSeq; | ||
| exports.binaryOptions = stringifyNumber.binaryOptions; | ||
| exports.boolOptions = stringifyNumber.boolOptions; | ||
| exports.intOptions = stringifyNumber.intOptions; | ||
| exports.nullOptions = stringifyNumber.nullOptions; | ||
| exports.strOptions = stringifyNumber.strOptions; | ||
| exports.Merge = Schema.Merge; | ||
| exports.binaryOptions = options.binaryOptions; | ||
| exports.boolOptions = options.boolOptions; | ||
| exports.intOptions = options.intOptions; | ||
| exports.nullOptions = options.nullOptions; | ||
| exports.strOptions = options.strOptions; | ||
| exports.Schema = Schema.Schema; | ||
| exports.Alias = Alias.Alias; | ||
| exports.Collection = Collection.Collection; | ||
| exports.Merge = Merge.Merge; | ||
| exports.Node = Node.Node; | ||
| exports.Pair = Pair.Pair; | ||
| exports.Scalar = Scalar.Scalar; | ||
| exports.YAMLMap = YAMLMap.YAMLMap; | ||
| exports.YAMLSeq = YAMLSeq.YAMLSeq; |
| 'use strict'; | ||
| var _rollupPluginBabelHelpers = require('./_rollupPluginBabelHelpers-eed30217.js'); | ||
| var stringifyNumber = require('./stringifyNumber-dea1120c.js'); | ||
| var stringifyNumber = require('./stringify/stringifyNumber.js'); | ||
| var stringifyString = require('./stringify/stringifyString.js'); | ||
| var constants = require('./constants.js'); | ||
| var errors = require('./errors.js'); | ||
| var YAMLMap = require('./ast/YAMLMap.js'); | ||
| var toJS = require('./ast/toJS.js'); | ||
| exports.Type = _rollupPluginBabelHelpers.Type; | ||
| exports.YAMLError = _rollupPluginBabelHelpers.YAMLError; | ||
| exports.YAMLReferenceError = _rollupPluginBabelHelpers.YAMLReferenceError; | ||
| exports.YAMLSemanticError = _rollupPluginBabelHelpers.YAMLSemanticError; | ||
| exports.YAMLSyntaxError = _rollupPluginBabelHelpers.YAMLSyntaxError; | ||
| exports.YAMLWarning = _rollupPluginBabelHelpers.YAMLWarning; | ||
| exports.findPair = stringifyNumber.findPair; | ||
| exports.stringifyNumber = stringifyNumber.stringifyNumber; | ||
| exports.stringifyString = stringifyNumber.stringifyString; | ||
| exports.toJS = stringifyNumber.toJS; | ||
| exports.stringifyString = stringifyString.stringifyString; | ||
| exports.Type = constants.Type; | ||
| exports.YAMLError = errors.YAMLError; | ||
| exports.YAMLReferenceError = errors.YAMLReferenceError; | ||
| exports.YAMLSemanticError = errors.YAMLSemanticError; | ||
| exports.YAMLSyntaxError = errors.YAMLSyntaxError; | ||
| exports.YAMLWarning = errors.YAMLWarning; | ||
| exports.findPair = YAMLMap.findPair; | ||
| exports.toJS = toJS.toJS; |
@@ -1,2 +0,2 @@ | ||
| import { CST } from './parse-cst' | ||
| import { CST } from './cst' | ||
| import { | ||
@@ -17,5 +17,69 @@ AST, | ||
| export { AST, CST } | ||
| export { default as parseCST } from './parse-cst' | ||
| export function parseCST(str: string): ParsedCST | ||
| export interface ParsedCST extends Array<CST.Document> { | ||
| setOrigRanges(): boolean | ||
| } | ||
| /** | ||
| * Apply a visitor to an AST node or document. | ||
| * | ||
| * Walks through the tree (depth-first) starting from `node`, calling a | ||
| * `visitor` function with three arguments: | ||
| * - `key`: For sequence values and map `Pair`, the node's index in the | ||
| * collection. Within a `Pair`, `'key'` or `'value'`, correspondingly. | ||
| * `null` for the root node. | ||
| * - `node`: The current node. | ||
| * - `path`: The ancestry of the current node. | ||
| * | ||
| * The return value of the visitor may be used to control the traversal: | ||
| * - `undefined` (default): Do nothing and continue | ||
| * - `visit.SKIP`: Do not visit the children of this node, continue with next | ||
| * sibling | ||
| * - `visit.BREAK`: Terminate traversal completely | ||
| * - `visit.REMOVE`: Remove the current node, then continue with the next one | ||
| * - `Node`: Replace the current node, then continue by visiting it | ||
| * - `number`: While iterating the items of a sequence or map, set the index | ||
| * of the next step. This is useful especially if the index of the current | ||
| * node has changed. | ||
| * | ||
| * If `visitor` is a single function, it will be called with all values | ||
| * encountered in the tree, including e.g. `null` values. Alternatively, | ||
| * separate visitor functions may be defined for each `Map`, `Pair`, `Seq`, | ||
| * `Alias` and `Scalar` node. | ||
| */ | ||
| export declare const visit: visit | ||
| export type visitor<T> = ( | ||
| key: number | 'key' | 'value' | null, | ||
| node: T, | ||
| path: Node[] | ||
| ) => void | symbol | number | Node | ||
| export interface visit { | ||
| ( | ||
| node: Node | Document, | ||
| visitor: | ||
| | visitor<any> | ||
| | { | ||
| Alias?: visitor<Alias> | ||
| Map?: visitor<YAMLMap> | ||
| Pair?: visitor<Pair> | ||
| Scalar?: visitor<Scalar> | ||
| Seq?: visitor<YAMLSeq> | ||
| } | ||
| ): void | ||
| /** Terminate visit traversal completely */ | ||
| BREAK: symbol | ||
| /** Remove the current node */ | ||
| REMOVE: symbol | ||
| /** Do not visit the children of the current node */ | ||
| SKIP: symbol | ||
| } | ||
| /** | ||
| * `yaml` defines document-specific options in three places: as an argument of | ||
@@ -333,3 +397,3 @@ * parse, create and stringify calls, in the values of `YAML.defaultOptions`, | ||
| interface Parsed extends Document { | ||
| contents: Node | null | ||
| contents: Scalar | YAMLMap | YAMLSeq | null | ||
| /** The schema used with the document. */ | ||
@@ -336,0 +400,0 @@ schema: Schema |
| { | ||
| "name": "yaml", | ||
| "version": "2.0.0-1", | ||
| "version": "2.0.0-2", | ||
| "license": "ISC", | ||
@@ -27,24 +27,27 @@ "author": "Eemeli Aro <eemeli@gmail.com>", | ||
| "./index.js": "./browser/index.js", | ||
| "./parse-cst.js": "./browser/parse-cst.js", | ||
| "./types.js": "./browser/types.js", | ||
| "./types.mjs": "./browser/types.js", | ||
| "./util.js": "./browser/util.js", | ||
| "./util.mjs": "./browser/util.js" | ||
| "./types.js": "./browser/dist/types.js", | ||
| "./types.mjs": "./browser/dist/types.js", | ||
| "./util.js": "./browser/dist/util.js", | ||
| "./util.mjs": "./browser/dist/util.js" | ||
| }, | ||
| "exports": { | ||
| ".": "./index.js", | ||
| ".": { | ||
| "node": "./index.js", | ||
| "default": "./browser/index.js" | ||
| }, | ||
| "./package.json": "./package.json", | ||
| "./parse-cst": "./parse-cst.js", | ||
| "./types": [ | ||
| { | ||
| "import": "./types.mjs" | ||
| "./types": { | ||
| "node": { | ||
| "import": "./types.mjs", | ||
| "require": "./types.js" | ||
| }, | ||
| "./types.js" | ||
| ], | ||
| "./util": [ | ||
| { | ||
| "import": "./util.mjs" | ||
| "default": "./browser/dist/types.js" | ||
| }, | ||
| "./util": { | ||
| "node": { | ||
| "import": "./util.mjs", | ||
| "require": "./util.js" | ||
| }, | ||
| "./util.js" | ||
| ] | ||
| "default": "./browser/dist/util.js" | ||
| } | ||
| }, | ||
@@ -69,3 +72,3 @@ "scripts": { | ||
| }, | ||
| "browserslist": "> 0.5%, not dead", | ||
| "browserslist": "> 0.5%, not dead, not ie 11", | ||
| "prettier": { | ||
@@ -78,22 +81,23 @@ "arrowParens": "avoid", | ||
| "devDependencies": { | ||
| "@babel/core": "^7.11.6", | ||
| "@babel/plugin-proposal-class-properties": "^7.10.4", | ||
| "@babel/preset-env": "^7.11.5", | ||
| "@rollup/plugin-babel": "^5.2.1", | ||
| "@babel/core": "^7.12.10", | ||
| "@babel/plugin-proposal-class-properties": "^7.12.1", | ||
| "@babel/plugin-proposal-nullish-coalescing-operator": "^7.12.1", | ||
| "@babel/preset-env": "^7.12.11", | ||
| "@rollup/plugin-babel": "^5.2.3", | ||
| "babel-eslint": "^10.1.0", | ||
| "babel-jest": "^26.5.0", | ||
| "babel-jest": "^26.6.3", | ||
| "babel-plugin-trace": "^1.1.0", | ||
| "common-tags": "^1.8.0", | ||
| "cross-env": "^7.0.2", | ||
| "eslint": "^7.10.0", | ||
| "eslint-config-prettier": "^6.12.0", | ||
| "fast-check": "^2.4.0", | ||
| "jest": "^26.5.0", | ||
| "prettier": "^2.1.2", | ||
| "rollup": "^2.28.2", | ||
| "typescript": "^4.0.3" | ||
| "cross-env": "^7.0.3", | ||
| "eslint": "^7.19.0", | ||
| "eslint-config-prettier": "^7.2.0", | ||
| "fast-check": "^2.12.0", | ||
| "jest": "^26.6.3", | ||
| "prettier": "^2.2.1", | ||
| "rollup": "^2.38.2", | ||
| "typescript": "^4.1.3" | ||
| }, | ||
| "engines": { | ||
| "node": ">= 6" | ||
| "node": ">= 10" | ||
| } | ||
| } |
@@ -5,3 +5,4 @@ # YAML <a href="https://www.npmjs.com/package/yaml"><img align="right" src="https://badge.fury.io/js/yaml.svg" title="npm package" /></a> | ||
| The library is released under the ISC open source license, and the code is [available on GitHub](https://github.com/eemeli/yaml/). It has no external dependencies and runs on Node.js 6 and later, and in browsers from IE 11 upwards. | ||
| The library is released under the ISC open source license, and the code is [available on GitHub](https://github.com/eemeli/yaml/). | ||
| It has no external dependencies and runs on Node.js as well as modern browsers. | ||
@@ -47,2 +48,3 @@ For the purposes of versioning, any changes that break any of the endpoints or APIs documented here will be considered semver-major breaking changes. Undocumented library internals may change between minor versions, and previous APIs may be deprecated (but not removed). | ||
| - [`YAML.parseDocument(str, options?): YAML.Document`](https://eemeli.org/yaml/#parsing-documents) | ||
| - [`YAML.visit(node, visitor)`](https://eemeli.org/yaml/#modifying-nodes) | ||
@@ -59,7 +61,2 @@ ```js | ||
| ```js | ||
| import parseCST from 'yaml/parse-cst' | ||
| ``` | ||
| - [`parseCST(str): CSTDocument[]`](https://eemeli.org/yaml/#parsecst) | ||
| - [`YAML.parseCST(str): CSTDocument[]`](https://eemeli.org/yaml/#parsecst) | ||
@@ -66,0 +63,0 @@ |
| import { Document, scalarOptions } from './index' | ||
| import { CST } from './parse-cst' | ||
| import { CST } from './cst' | ||
| import { Type } from './util' | ||
@@ -4,0 +4,0 @@ |
@@ -1,2 +0,2 @@ | ||
| import { CST } from './parse-cst' | ||
| import { CST } from './cst' | ||
| import { Pair, Scalar, Schema } from './types' | ||
@@ -3,0 +3,0 @@ |
New alerts
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
Fixed alerts
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
Environment variable access
Supply chain riskPackage accesses environment variables, which may be a sign of credential stuffing or data theft.
Found 1 instance in 1 package
Improved metrics
- Number of package files
- increased by348.57%
157
- Number of low supply chain risk alerts
- decreased by-100%
0
Worsened metrics
- Total package byte prevSize
- decreased by-3.71%
442342
- Dev dependency count
- increased by6.25%
17
- Lines of code
- decreased by-1.53%
13382
- Number of lines in readme file
- decreased by-2.36%
124
No dependency changes