7520 lines
210 KiB
JavaScript
7520 lines
210 KiB
JavaScript
(function (f) {
|
|
function e() {
|
|
var i = f();
|
|
return i.default || i;
|
|
}
|
|
if (typeof exports == 'object' && typeof module == 'object')
|
|
module.exports = e();
|
|
else if (typeof define == 'function' && define.amd) define(e);
|
|
else {
|
|
var t =
|
|
typeof globalThis < 'u' ? globalThis
|
|
: typeof global < 'u' ? global
|
|
: typeof self < 'u' ? self
|
|
: this || {};
|
|
(t.prettierPlugins = t.prettierPlugins || {}),
|
|
(t.prettierPlugins.yaml = e());
|
|
}
|
|
})(function () {
|
|
'use strict';
|
|
var Ti = Object.create;
|
|
var yt = Object.defineProperty;
|
|
var Ci = Object.getOwnPropertyDescriptor;
|
|
var Mi = Object.getOwnPropertyNames;
|
|
var ki = Object.getPrototypeOf,
|
|
vi = Object.prototype.hasOwnProperty;
|
|
var te = (t, e) => () => (
|
|
e || t((e = { exports: {} }).exports, e), e.exports
|
|
),
|
|
nr = (t, e) => {
|
|
for (var n in e) yt(t, n, { get: e[n], enumerable: !0 });
|
|
},
|
|
rr = (t, e, n, r) => {
|
|
if ((e && typeof e == 'object') || typeof e == 'function')
|
|
for (let s of Mi(e))
|
|
!vi.call(t, s) &&
|
|
s !== n &&
|
|
yt(t, s, {
|
|
get: () => e[s],
|
|
enumerable: !(r = Ci(e, s)) || r.enumerable,
|
|
});
|
|
return t;
|
|
};
|
|
var sr = (t, e, n) => (
|
|
(n = t != null ? Ti(ki(t)) : {}),
|
|
rr(
|
|
e || !t || !t.__esModule ?
|
|
yt(n, 'default', { value: t, enumerable: !0 })
|
|
: n,
|
|
t
|
|
)
|
|
),
|
|
Ii = (t) => rr(yt({}, '__esModule', { value: !0 }), t);
|
|
var le = te((U) => {
|
|
'use strict';
|
|
var re = {
|
|
ANCHOR: '&',
|
|
COMMENT: '#',
|
|
TAG: '!',
|
|
DIRECTIVES_END: '-',
|
|
DOCUMENT_END: '.',
|
|
},
|
|
lt = {
|
|
ALIAS: 'ALIAS',
|
|
BLANK_LINE: 'BLANK_LINE',
|
|
BLOCK_FOLDED: 'BLOCK_FOLDED',
|
|
BLOCK_LITERAL: 'BLOCK_LITERAL',
|
|
COMMENT: 'COMMENT',
|
|
DIRECTIVE: 'DIRECTIVE',
|
|
DOCUMENT: 'DOCUMENT',
|
|
FLOW_MAP: 'FLOW_MAP',
|
|
FLOW_SEQ: 'FLOW_SEQ',
|
|
MAP: 'MAP',
|
|
MAP_KEY: 'MAP_KEY',
|
|
MAP_VALUE: 'MAP_VALUE',
|
|
PLAIN: 'PLAIN',
|
|
QUOTE_DOUBLE: 'QUOTE_DOUBLE',
|
|
QUOTE_SINGLE: 'QUOTE_SINGLE',
|
|
SEQ: 'SEQ',
|
|
SEQ_ITEM: 'SEQ_ITEM',
|
|
},
|
|
Ao = 'tag:yaml.org,2002:',
|
|
To = {
|
|
MAP: 'tag:yaml.org,2002:map',
|
|
SEQ: 'tag:yaml.org,2002:seq',
|
|
STR: 'tag:yaml.org,2002:str',
|
|
};
|
|
function Ps(t) {
|
|
let e = [0],
|
|
n = t.indexOf(`
|
|
`);
|
|
for (; n !== -1; )
|
|
(n += 1),
|
|
e.push(n),
|
|
(n = t.indexOf(
|
|
`
|
|
`,
|
|
n
|
|
));
|
|
return e;
|
|
}
|
|
function _s(t) {
|
|
let e, n;
|
|
return (
|
|
typeof t == 'string' ?
|
|
((e = Ps(t)), (n = t))
|
|
: (Array.isArray(t) && (t = t[0]),
|
|
t &&
|
|
t.context &&
|
|
(t.lineStarts || (t.lineStarts = Ps(t.context.src)),
|
|
(e = t.lineStarts),
|
|
(n = t.context.src))),
|
|
{ lineStarts: e, src: n }
|
|
);
|
|
}
|
|
function Tn(t, e) {
|
|
if (typeof t != 'number' || t < 0) return null;
|
|
let { lineStarts: n, src: r } = _s(e);
|
|
if (!n || !r || t > r.length) return null;
|
|
for (let i = 0; i < n.length; ++i) {
|
|
let o = n[i];
|
|
if (t < o) return { line: i, col: t - n[i - 1] + 1 };
|
|
if (t === o) return { line: i + 1, col: 1 };
|
|
}
|
|
let s = n.length;
|
|
return { line: s, col: t - n[s - 1] + 1 };
|
|
}
|
|
function Co(t, e) {
|
|
let { lineStarts: n, src: r } = _s(e);
|
|
if (!n || !(t >= 1) || t > n.length) return null;
|
|
let s = n[t - 1],
|
|
i = n[t];
|
|
for (
|
|
;
|
|
i &&
|
|
i > s &&
|
|
r[i - 1] ===
|
|
`
|
|
`;
|
|
|
|
)
|
|
--i;
|
|
return r.slice(s, i);
|
|
}
|
|
function Mo({ start: t, end: e }, n, r = 80) {
|
|
let s = Co(t.line, n);
|
|
if (!s) return null;
|
|
let { col: i } = t;
|
|
if (s.length > r)
|
|
if (i <= r - 10) s = s.substr(0, r - 1) + '\u2026';
|
|
else {
|
|
let f = Math.round(r / 2);
|
|
s.length > i + f && (s = s.substr(0, i + f - 1) + '\u2026'),
|
|
(i -= s.length - r),
|
|
(s = '\u2026' + s.substr(1 - r));
|
|
}
|
|
let o = 1,
|
|
a = '';
|
|
e &&
|
|
(e.line === t.line && i + (e.col - t.col) <= r + 1 ?
|
|
(o = e.col - t.col)
|
|
: ((o = Math.min(s.length + 1, r) - i), (a = '\u2026')));
|
|
let c = i > 1 ? ' '.repeat(i - 1) : '',
|
|
l = '^'.repeat(o);
|
|
return `${s}
|
|
${c}${l}${a}`;
|
|
}
|
|
var Be = class t {
|
|
static copy(e) {
|
|
return new t(e.start, e.end);
|
|
}
|
|
constructor(e, n) {
|
|
(this.start = e), (this.end = n || e);
|
|
}
|
|
isEmpty() {
|
|
return (
|
|
typeof this.start != 'number' || !this.end || this.end <= this.start
|
|
);
|
|
}
|
|
setOrigRange(e, n) {
|
|
let { start: r, end: s } = this;
|
|
if (e.length === 0 || s <= e[0])
|
|
return (this.origStart = r), (this.origEnd = s), n;
|
|
let i = n;
|
|
for (; i < e.length && !(e[i] > r); ) ++i;
|
|
this.origStart = r + i;
|
|
let o = i;
|
|
for (; i < e.length && !(e[i] >= s); ) ++i;
|
|
return (this.origEnd = s + i), o;
|
|
}
|
|
},
|
|
se = class t {
|
|
static addStringTerminator(e, n, r) {
|
|
if (
|
|
r[r.length - 1] ===
|
|
`
|
|
`
|
|
)
|
|
return r;
|
|
let s = t.endOfWhiteSpace(e, n);
|
|
return (
|
|
s >= e.length ||
|
|
e[s] ===
|
|
`
|
|
`
|
|
) ?
|
|
r +
|
|
`
|
|
`
|
|
: r;
|
|
}
|
|
static atDocumentBoundary(e, n, r) {
|
|
let s = e[n];
|
|
if (!s) return !0;
|
|
let i = e[n - 1];
|
|
if (
|
|
i &&
|
|
i !==
|
|
`
|
|
`
|
|
)
|
|
return !1;
|
|
if (r) {
|
|
if (s !== r) return !1;
|
|
} else if (s !== re.DIRECTIVES_END && s !== re.DOCUMENT_END)
|
|
return !1;
|
|
let o = e[n + 1],
|
|
a = e[n + 2];
|
|
if (o !== s || a !== s) return !1;
|
|
let c = e[n + 3];
|
|
return (
|
|
!c ||
|
|
c ===
|
|
`
|
|
` ||
|
|
c === ' ' ||
|
|
c === ' '
|
|
);
|
|
}
|
|
static endOfIdentifier(e, n) {
|
|
let r = e[n],
|
|
s = r === '<',
|
|
i =
|
|
s ?
|
|
[
|
|
`
|
|
`,
|
|
' ',
|
|
' ',
|
|
'>',
|
|
]
|
|
: [
|
|
`
|
|
`,
|
|
' ',
|
|
' ',
|
|
'[',
|
|
']',
|
|
'{',
|
|
'}',
|
|
',',
|
|
];
|
|
for (; r && i.indexOf(r) === -1; ) r = e[(n += 1)];
|
|
return s && r === '>' && (n += 1), n;
|
|
}
|
|
static endOfIndent(e, n) {
|
|
let r = e[n];
|
|
for (; r === ' '; ) r = e[(n += 1)];
|
|
return n;
|
|
}
|
|
static endOfLine(e, n) {
|
|
let r = e[n];
|
|
for (
|
|
;
|
|
r &&
|
|
r !==
|
|
`
|
|
`;
|
|
|
|
)
|
|
r = e[(n += 1)];
|
|
return n;
|
|
}
|
|
static endOfWhiteSpace(e, n) {
|
|
let r = e[n];
|
|
for (; r === ' ' || r === ' '; ) r = e[(n += 1)];
|
|
return n;
|
|
}
|
|
static startOfLine(e, n) {
|
|
let r = e[n - 1];
|
|
if (
|
|
r ===
|
|
`
|
|
`
|
|
)
|
|
return n;
|
|
for (
|
|
;
|
|
r &&
|
|
r !==
|
|
`
|
|
`;
|
|
|
|
)
|
|
r = e[(n -= 1)];
|
|
return n + 1;
|
|
}
|
|
static endOfBlockIndent(e, n, r) {
|
|
let s = t.endOfIndent(e, r);
|
|
if (s > r + n) return s;
|
|
{
|
|
let i = t.endOfWhiteSpace(e, s),
|
|
o = e[i];
|
|
if (
|
|
!o ||
|
|
o ===
|
|
`
|
|
`
|
|
)
|
|
return i;
|
|
}
|
|
return null;
|
|
}
|
|
static atBlank(e, n, r) {
|
|
let s = e[n];
|
|
return (
|
|
s ===
|
|
`
|
|
` ||
|
|
s === ' ' ||
|
|
s === ' ' ||
|
|
(r && !s)
|
|
);
|
|
}
|
|
static nextNodeIsIndented(e, n, r) {
|
|
return (
|
|
!e || n < 0 ? !1
|
|
: n > 0 ? !0
|
|
: r && e === '-'
|
|
);
|
|
}
|
|
static normalizeOffset(e, n) {
|
|
let r = e[n];
|
|
return (
|
|
r ?
|
|
(
|
|
r !==
|
|
`
|
|
` &&
|
|
e[n - 1] ===
|
|
`
|
|
`
|
|
) ?
|
|
n - 1
|
|
: t.endOfWhiteSpace(e, n)
|
|
: n
|
|
);
|
|
}
|
|
static foldNewline(e, n, r) {
|
|
let s = 0,
|
|
i = !1,
|
|
o = '',
|
|
a = e[n + 1];
|
|
for (
|
|
;
|
|
a === ' ' ||
|
|
a === ' ' ||
|
|
a ===
|
|
`
|
|
`;
|
|
|
|
) {
|
|
switch (a) {
|
|
case `
|
|
`:
|
|
(s = 0),
|
|
(n += 1),
|
|
(o += `
|
|
`);
|
|
break;
|
|
case ' ':
|
|
s <= r && (i = !0), (n = t.endOfWhiteSpace(e, n + 2) - 1);
|
|
break;
|
|
case ' ':
|
|
(s += 1), (n += 1);
|
|
break;
|
|
}
|
|
a = e[n + 1];
|
|
}
|
|
return (
|
|
o || (o = ' '),
|
|
a && s <= r && (i = !0),
|
|
{ fold: o, offset: n, error: i }
|
|
);
|
|
}
|
|
constructor(e, n, r) {
|
|
Object.defineProperty(this, 'context', {
|
|
value: r || null,
|
|
writable: !0,
|
|
}),
|
|
(this.error = null),
|
|
(this.range = null),
|
|
(this.valueRange = null),
|
|
(this.props = n || []),
|
|
(this.type = e),
|
|
(this.value = null);
|
|
}
|
|
getPropValue(e, n, r) {
|
|
if (!this.context) return null;
|
|
let { src: s } = this.context,
|
|
i = this.props[e];
|
|
return i && s[i.start] === n ?
|
|
s.slice(i.start + (r ? 1 : 0), i.end)
|
|
: null;
|
|
}
|
|
get anchor() {
|
|
for (let e = 0; e < this.props.length; ++e) {
|
|
let n = this.getPropValue(e, re.ANCHOR, !0);
|
|
if (n != null) return n;
|
|
}
|
|
return null;
|
|
}
|
|
get comment() {
|
|
let e = [];
|
|
for (let n = 0; n < this.props.length; ++n) {
|
|
let r = this.getPropValue(n, re.COMMENT, !0);
|
|
r != null && e.push(r);
|
|
}
|
|
return e.length > 0 ?
|
|
e.join(`
|
|
`)
|
|
: null;
|
|
}
|
|
commentHasRequiredWhitespace(e) {
|
|
let { src: n } = this.context;
|
|
if ((this.header && e === this.header.end) || !this.valueRange)
|
|
return !1;
|
|
let { end: r } = this.valueRange;
|
|
return e !== r || t.atBlank(n, r - 1);
|
|
}
|
|
get hasComment() {
|
|
if (this.context) {
|
|
let { src: e } = this.context;
|
|
for (let n = 0; n < this.props.length; ++n)
|
|
if (e[this.props[n].start] === re.COMMENT) return !0;
|
|
}
|
|
return !1;
|
|
}
|
|
get hasProps() {
|
|
if (this.context) {
|
|
let { src: e } = this.context;
|
|
for (let n = 0; n < this.props.length; ++n)
|
|
if (e[this.props[n].start] !== re.COMMENT) return !0;
|
|
}
|
|
return !1;
|
|
}
|
|
get includesTrailingLines() {
|
|
return !1;
|
|
}
|
|
get jsonLike() {
|
|
return (
|
|
[
|
|
lt.FLOW_MAP,
|
|
lt.FLOW_SEQ,
|
|
lt.QUOTE_DOUBLE,
|
|
lt.QUOTE_SINGLE,
|
|
].indexOf(this.type) !== -1
|
|
);
|
|
}
|
|
get rangeAsLinePos() {
|
|
if (!this.range || !this.context) return;
|
|
let e = Tn(this.range.start, this.context.root);
|
|
if (!e) return;
|
|
let n = Tn(this.range.end, this.context.root);
|
|
return { start: e, end: n };
|
|
}
|
|
get rawValue() {
|
|
if (!this.valueRange || !this.context) return null;
|
|
let { start: e, end: n } = this.valueRange;
|
|
return this.context.src.slice(e, n);
|
|
}
|
|
get tag() {
|
|
for (let e = 0; e < this.props.length; ++e) {
|
|
let n = this.getPropValue(e, re.TAG, !1);
|
|
if (n != null) {
|
|
if (n[1] === '<') return { verbatim: n.slice(2, -1) };
|
|
{
|
|
let [r, s, i] = n.match(/^(.*!)([^!]*)$/);
|
|
return { handle: s, suffix: i };
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
get valueRangeContainsNewline() {
|
|
if (!this.valueRange || !this.context) return !1;
|
|
let { start: e, end: n } = this.valueRange,
|
|
{ src: r } = this.context;
|
|
for (let s = e; s < n; ++s)
|
|
if (
|
|
r[s] ===
|
|
`
|
|
`
|
|
)
|
|
return !0;
|
|
return !1;
|
|
}
|
|
parseComment(e) {
|
|
let { src: n } = this.context;
|
|
if (n[e] === re.COMMENT) {
|
|
let r = t.endOfLine(n, e + 1),
|
|
s = new Be(e, r);
|
|
return this.props.push(s), r;
|
|
}
|
|
return e;
|
|
}
|
|
setOrigRanges(e, n) {
|
|
return (
|
|
this.range && (n = this.range.setOrigRange(e, n)),
|
|
this.valueRange && this.valueRange.setOrigRange(e, n),
|
|
this.props.forEach((r) => r.setOrigRange(e, n)),
|
|
n
|
|
);
|
|
}
|
|
toString() {
|
|
let {
|
|
context: { src: e },
|
|
range: n,
|
|
value: r,
|
|
} = this;
|
|
if (r != null) return r;
|
|
let s = e.slice(n.start, n.end);
|
|
return t.addStringTerminator(e, n.end, s);
|
|
}
|
|
},
|
|
ye = class extends Error {
|
|
constructor(e, n, r) {
|
|
if (!r || !(n instanceof se))
|
|
throw new Error(`Invalid arguments for new ${e}`);
|
|
super(), (this.name = e), (this.message = r), (this.source = n);
|
|
}
|
|
makePretty() {
|
|
if (!this.source) return;
|
|
this.nodeType = this.source.type;
|
|
let e = this.source.context && this.source.context.root;
|
|
if (typeof this.offset == 'number') {
|
|
this.range = new Be(this.offset, this.offset + 1);
|
|
let n = e && Tn(this.offset, e);
|
|
if (n) {
|
|
let r = { line: n.line, col: n.col + 1 };
|
|
this.linePos = { start: n, end: r };
|
|
}
|
|
delete this.offset;
|
|
} else
|
|
(this.range = this.source.range),
|
|
(this.linePos = this.source.rangeAsLinePos);
|
|
if (this.linePos) {
|
|
let { line: n, col: r } = this.linePos.start;
|
|
this.message += ` at line ${n}, column ${r}`;
|
|
let s = e && Mo(this.linePos, e);
|
|
s &&
|
|
(this.message += `:
|
|
|
|
${s}
|
|
`);
|
|
}
|
|
delete this.source;
|
|
}
|
|
},
|
|
Cn = class extends ye {
|
|
constructor(e, n) {
|
|
super('YAMLReferenceError', e, n);
|
|
}
|
|
},
|
|
ft = class extends ye {
|
|
constructor(e, n) {
|
|
super('YAMLSemanticError', e, n);
|
|
}
|
|
},
|
|
Mn = class extends ye {
|
|
constructor(e, n) {
|
|
super('YAMLSyntaxError', e, n);
|
|
}
|
|
},
|
|
kn = class extends ye {
|
|
constructor(e, n) {
|
|
super('YAMLWarning', e, n);
|
|
}
|
|
};
|
|
function ko(t, e, n) {
|
|
return (
|
|
e in t ?
|
|
Object.defineProperty(t, e, {
|
|
value: n,
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
writable: !0,
|
|
})
|
|
: (t[e] = n),
|
|
t
|
|
);
|
|
}
|
|
var vn = class t extends se {
|
|
static endOfLine(e, n, r) {
|
|
let s = e[n],
|
|
i = n;
|
|
for (
|
|
;
|
|
s &&
|
|
s !==
|
|
`
|
|
` &&
|
|
!(
|
|
r &&
|
|
(s === '[' || s === ']' || s === '{' || s === '}' || s === ',')
|
|
);
|
|
|
|
) {
|
|
let o = e[i + 1];
|
|
if (
|
|
(s === ':' &&
|
|
(!o ||
|
|
o ===
|
|
`
|
|
` ||
|
|
o === ' ' ||
|
|
o === ' ' ||
|
|
(r && o === ','))) ||
|
|
((s === ' ' || s === ' ') && o === '#')
|
|
)
|
|
break;
|
|
(i += 1), (s = o);
|
|
}
|
|
return i;
|
|
}
|
|
get strValue() {
|
|
if (!this.valueRange || !this.context) return null;
|
|
let { start: e, end: n } = this.valueRange,
|
|
{ src: r } = this.context,
|
|
s = r[n - 1];
|
|
for (
|
|
;
|
|
e < n &&
|
|
(s ===
|
|
`
|
|
` ||
|
|
s === ' ' ||
|
|
s === ' ');
|
|
|
|
)
|
|
s = r[--n - 1];
|
|
let i = '';
|
|
for (let a = e; a < n; ++a) {
|
|
let c = r[a];
|
|
if (
|
|
c ===
|
|
`
|
|
`
|
|
) {
|
|
let { fold: l, offset: f } = se.foldNewline(r, a, -1);
|
|
(i += l), (a = f);
|
|
} else if (c === ' ' || c === ' ') {
|
|
let l = a,
|
|
f = r[a + 1];
|
|
for (; a < n && (f === ' ' || f === ' '); ) (a += 1), (f = r[a + 1]);
|
|
f !==
|
|
`
|
|
` && (i += a > l ? r.slice(l, a + 1) : c);
|
|
} else i += c;
|
|
}
|
|
let o = r[e];
|
|
switch (o) {
|
|
case ' ': {
|
|
let a = 'Plain value cannot start with a tab character';
|
|
return { errors: [new ft(this, a)], str: i };
|
|
}
|
|
case '@':
|
|
case '`': {
|
|
let a = `Plain value cannot start with reserved character ${o}`;
|
|
return { errors: [new ft(this, a)], str: i };
|
|
}
|
|
default:
|
|
return i;
|
|
}
|
|
}
|
|
parseBlockValue(e) {
|
|
let { indent: n, inFlow: r, src: s } = this.context,
|
|
i = e,
|
|
o = e;
|
|
for (
|
|
let a = s[i];
|
|
a ===
|
|
`
|
|
` && !se.atDocumentBoundary(s, i + 1);
|
|
a = s[i]
|
|
) {
|
|
let c = se.endOfBlockIndent(s, n, i + 1);
|
|
if (c === null || s[c] === '#') break;
|
|
(
|
|
s[c] ===
|
|
`
|
|
`
|
|
) ?
|
|
(i = c)
|
|
: ((o = t.endOfLine(s, c, r)), (i = o));
|
|
}
|
|
return (
|
|
this.valueRange.isEmpty() && (this.valueRange.start = e),
|
|
(this.valueRange.end = o),
|
|
o
|
|
);
|
|
}
|
|
parse(e, n) {
|
|
this.context = e;
|
|
let { inFlow: r, src: s } = e,
|
|
i = n,
|
|
o = s[i];
|
|
return (
|
|
o &&
|
|
o !== '#' &&
|
|
o !==
|
|
`
|
|
` &&
|
|
(i = t.endOfLine(s, n, r)),
|
|
(this.valueRange = new Be(n, i)),
|
|
(i = se.endOfWhiteSpace(s, i)),
|
|
(i = this.parseComment(i)),
|
|
(!this.hasComment || this.valueRange.isEmpty()) &&
|
|
(i = this.parseBlockValue(i)),
|
|
i
|
|
);
|
|
}
|
|
};
|
|
U.Char = re;
|
|
U.Node = se;
|
|
U.PlainValue = vn;
|
|
U.Range = Be;
|
|
U.Type = lt;
|
|
U.YAMLError = ye;
|
|
U.YAMLReferenceError = Cn;
|
|
U.YAMLSemanticError = ft;
|
|
U.YAMLSyntaxError = Mn;
|
|
U.YAMLWarning = kn;
|
|
U._defineProperty = ko;
|
|
U.defaultTagPrefix = Ao;
|
|
U.defaultTags = To;
|
|
});
|
|
var Rs = te((xs) => {
|
|
'use strict';
|
|
var u = le(),
|
|
Se = class extends u.Node {
|
|
constructor() {
|
|
super(u.Type.BLANK_LINE);
|
|
}
|
|
get includesTrailingLines() {
|
|
return !0;
|
|
}
|
|
parse(e, n) {
|
|
return (
|
|
(this.context = e), (this.range = new u.Range(n, n + 1)), n + 1
|
|
);
|
|
}
|
|
},
|
|
ut = class extends u.Node {
|
|
constructor(e, n) {
|
|
super(e, n), (this.node = null);
|
|
}
|
|
get includesTrailingLines() {
|
|
return !!this.node && this.node.includesTrailingLines;
|
|
}
|
|
parse(e, n) {
|
|
this.context = e;
|
|
let { parseNode: r, src: s } = e,
|
|
{ atLineStart: i, lineStart: o } = e;
|
|
!i &&
|
|
this.type === u.Type.SEQ_ITEM &&
|
|
(this.error = new u.YAMLSemanticError(
|
|
this,
|
|
'Sequence items must not have preceding content on the same line'
|
|
));
|
|
let a = i ? n - o : e.indent,
|
|
c = u.Node.endOfWhiteSpace(s, n + 1),
|
|
l = s[c],
|
|
f = l === '#',
|
|
m = [],
|
|
d = null;
|
|
for (
|
|
;
|
|
l ===
|
|
`
|
|
` || l === '#';
|
|
|
|
) {
|
|
if (l === '#') {
|
|
let h = u.Node.endOfLine(s, c + 1);
|
|
m.push(new u.Range(c, h)), (c = h);
|
|
} else {
|
|
(i = !0), (o = c + 1);
|
|
let h = u.Node.endOfWhiteSpace(s, o);
|
|
s[h] ===
|
|
`
|
|
` &&
|
|
m.length === 0 &&
|
|
((d = new Se()), (o = d.parse({ src: s }, o))),
|
|
(c = u.Node.endOfIndent(s, o));
|
|
}
|
|
l = s[c];
|
|
}
|
|
if (
|
|
((
|
|
u.Node.nextNodeIsIndented(
|
|
l,
|
|
c - (o + a),
|
|
this.type !== u.Type.SEQ_ITEM
|
|
)
|
|
) ?
|
|
(this.node = r(
|
|
{
|
|
atLineStart: i,
|
|
inCollection: !1,
|
|
indent: a,
|
|
lineStart: o,
|
|
parent: this,
|
|
},
|
|
c
|
|
))
|
|
: l && o > n + 1 && (c = o - 1),
|
|
this.node)
|
|
) {
|
|
if (d) {
|
|
let h = e.parent.items || e.parent.contents;
|
|
h && h.push(d);
|
|
}
|
|
m.length && Array.prototype.push.apply(this.props, m),
|
|
(c = this.node.range.end);
|
|
} else if (f) {
|
|
let h = m[0];
|
|
this.props.push(h), (c = h.end);
|
|
} else c = u.Node.endOfLine(s, n + 1);
|
|
let y = this.node ? this.node.valueRange.end : c;
|
|
return (this.valueRange = new u.Range(n, y)), c;
|
|
}
|
|
setOrigRanges(e, n) {
|
|
return (
|
|
(n = super.setOrigRanges(e, n)),
|
|
this.node ? this.node.setOrigRanges(e, n) : n
|
|
);
|
|
}
|
|
toString() {
|
|
let {
|
|
context: { src: e },
|
|
node: n,
|
|
range: r,
|
|
value: s,
|
|
} = this;
|
|
if (s != null) return s;
|
|
let i =
|
|
n ?
|
|
e.slice(r.start, n.range.start) + String(n)
|
|
: e.slice(r.start, r.end);
|
|
return u.Node.addStringTerminator(e, r.end, i);
|
|
}
|
|
},
|
|
Ee = class extends u.Node {
|
|
constructor() {
|
|
super(u.Type.COMMENT);
|
|
}
|
|
parse(e, n) {
|
|
this.context = e;
|
|
let r = this.parseComment(n);
|
|
return (this.range = new u.Range(n, r)), r;
|
|
}
|
|
};
|
|
function In(t) {
|
|
let e = t;
|
|
for (; e instanceof ut; ) e = e.node;
|
|
if (!(e instanceof Bt)) return null;
|
|
let n = e.items.length,
|
|
r = -1;
|
|
for (let o = n - 1; o >= 0; --o) {
|
|
let a = e.items[o];
|
|
if (a.type === u.Type.COMMENT) {
|
|
let { indent: c, lineStart: l } = a.context;
|
|
if (c > 0 && a.range.start >= l + c) break;
|
|
r = o;
|
|
} else if (a.type === u.Type.BLANK_LINE) r = o;
|
|
else break;
|
|
}
|
|
if (r === -1) return null;
|
|
let s = e.items.splice(r, n - r),
|
|
i = s[0].range.start;
|
|
for (
|
|
;
|
|
(e.range.end = i),
|
|
e.valueRange && e.valueRange.end > i && (e.valueRange.end = i),
|
|
e !== t;
|
|
|
|
)
|
|
e = e.context.parent;
|
|
return s;
|
|
}
|
|
var Bt = class t extends u.Node {
|
|
static nextContentHasIndent(e, n, r) {
|
|
let s = u.Node.endOfLine(e, n) + 1;
|
|
n = u.Node.endOfWhiteSpace(e, s);
|
|
let i = e[n];
|
|
return (
|
|
i ?
|
|
n >= s + r ? !0
|
|
: (
|
|
i !== '#' &&
|
|
i !==
|
|
`
|
|
`
|
|
) ?
|
|
!1
|
|
: t.nextContentHasIndent(e, n, r)
|
|
: !1
|
|
);
|
|
}
|
|
constructor(e) {
|
|
super(e.type === u.Type.SEQ_ITEM ? u.Type.SEQ : u.Type.MAP);
|
|
for (let r = e.props.length - 1; r >= 0; --r)
|
|
if (e.props[r].start < e.context.lineStart) {
|
|
(this.props = e.props.slice(0, r + 1)),
|
|
(e.props = e.props.slice(r + 1));
|
|
let s = e.props[0] || e.valueRange;
|
|
e.range.start = s.start;
|
|
break;
|
|
}
|
|
this.items = [e];
|
|
let n = In(e);
|
|
n && Array.prototype.push.apply(this.items, n);
|
|
}
|
|
get includesTrailingLines() {
|
|
return this.items.length > 0;
|
|
}
|
|
parse(e, n) {
|
|
this.context = e;
|
|
let { parseNode: r, src: s } = e,
|
|
i = u.Node.startOfLine(s, n),
|
|
o = this.items[0];
|
|
(o.context.parent = this),
|
|
(this.valueRange = u.Range.copy(o.valueRange));
|
|
let a = o.range.start - o.context.lineStart,
|
|
c = n;
|
|
c = u.Node.normalizeOffset(s, c);
|
|
let l = s[c],
|
|
f = u.Node.endOfWhiteSpace(s, i) === c,
|
|
m = !1;
|
|
for (; l; ) {
|
|
for (
|
|
;
|
|
l ===
|
|
`
|
|
` || l === '#';
|
|
|
|
) {
|
|
if (
|
|
f &&
|
|
l ===
|
|
`
|
|
` &&
|
|
!m
|
|
) {
|
|
let h = new Se();
|
|
if (
|
|
((c = h.parse({ src: s }, c)),
|
|
(this.valueRange.end = c),
|
|
c >= s.length)
|
|
) {
|
|
l = null;
|
|
break;
|
|
}
|
|
this.items.push(h), (c -= 1);
|
|
} else if (l === '#') {
|
|
if (c < i + a && !t.nextContentHasIndent(s, c, a)) return c;
|
|
let h = new Ee();
|
|
if (
|
|
((c = h.parse({ indent: a, lineStart: i, src: s }, c)),
|
|
this.items.push(h),
|
|
(this.valueRange.end = c),
|
|
c >= s.length)
|
|
) {
|
|
l = null;
|
|
break;
|
|
}
|
|
}
|
|
if (
|
|
((i = c + 1),
|
|
(c = u.Node.endOfIndent(s, i)),
|
|
u.Node.atBlank(s, c))
|
|
) {
|
|
let h = u.Node.endOfWhiteSpace(s, c),
|
|
g = s[h];
|
|
(!g ||
|
|
g ===
|
|
`
|
|
` ||
|
|
g === '#') &&
|
|
(c = h);
|
|
}
|
|
(l = s[c]), (f = !0);
|
|
}
|
|
if (!l) break;
|
|
if (c !== i + a && (f || l !== ':')) {
|
|
if (c < i + a) {
|
|
i > n && (c = i);
|
|
break;
|
|
} else if (!this.error) {
|
|
let h = 'All collection items must start at the same column';
|
|
this.error = new u.YAMLSyntaxError(this, h);
|
|
}
|
|
}
|
|
if (o.type === u.Type.SEQ_ITEM) {
|
|
if (l !== '-') {
|
|
i > n && (c = i);
|
|
break;
|
|
}
|
|
} else if (l === '-' && !this.error) {
|
|
let h = s[c + 1];
|
|
if (
|
|
!h ||
|
|
h ===
|
|
`
|
|
` ||
|
|
h === ' ' ||
|
|
h === ' '
|
|
) {
|
|
let g = 'A collection cannot be both a mapping and a sequence';
|
|
this.error = new u.YAMLSyntaxError(this, g);
|
|
}
|
|
}
|
|
let d = r(
|
|
{
|
|
atLineStart: f,
|
|
inCollection: !0,
|
|
indent: a,
|
|
lineStart: i,
|
|
parent: this,
|
|
},
|
|
c
|
|
);
|
|
if (!d) return c;
|
|
if (
|
|
(this.items.push(d),
|
|
(this.valueRange.end = d.valueRange.end),
|
|
(c = u.Node.normalizeOffset(s, d.range.end)),
|
|
(l = s[c]),
|
|
(f = !1),
|
|
(m = d.includesTrailingLines),
|
|
l)
|
|
) {
|
|
let h = c - 1,
|
|
g = s[h];
|
|
for (; g === ' ' || g === ' '; ) g = s[--h];
|
|
g ===
|
|
`
|
|
` && ((i = h + 1), (f = !0));
|
|
}
|
|
let y = In(d);
|
|
y && Array.prototype.push.apply(this.items, y);
|
|
}
|
|
return c;
|
|
}
|
|
setOrigRanges(e, n) {
|
|
return (
|
|
(n = super.setOrigRanges(e, n)),
|
|
this.items.forEach((r) => {
|
|
n = r.setOrigRanges(e, n);
|
|
}),
|
|
n
|
|
);
|
|
}
|
|
toString() {
|
|
let {
|
|
context: { src: e },
|
|
items: n,
|
|
range: r,
|
|
value: s,
|
|
} = this;
|
|
if (s != null) return s;
|
|
let i = e.slice(r.start, n[0].range.start) + String(n[0]);
|
|
for (let o = 1; o < n.length; ++o) {
|
|
let a = n[o],
|
|
{ atLineStart: c, indent: l } = a.context;
|
|
if (c) for (let f = 0; f < l; ++f) i += ' ';
|
|
i += String(a);
|
|
}
|
|
return u.Node.addStringTerminator(e, r.end, i);
|
|
}
|
|
},
|
|
Pn = class extends u.Node {
|
|
constructor() {
|
|
super(u.Type.DIRECTIVE), (this.name = null);
|
|
}
|
|
get parameters() {
|
|
let e = this.rawValue;
|
|
return e ? e.trim().split(/[ \t]+/) : [];
|
|
}
|
|
parseName(e) {
|
|
let { src: n } = this.context,
|
|
r = e,
|
|
s = n[r];
|
|
for (
|
|
;
|
|
s &&
|
|
s !==
|
|
`
|
|
` &&
|
|
s !== ' ' &&
|
|
s !== ' ';
|
|
|
|
)
|
|
s = n[(r += 1)];
|
|
return (this.name = n.slice(e, r)), r;
|
|
}
|
|
parseParameters(e) {
|
|
let { src: n } = this.context,
|
|
r = e,
|
|
s = n[r];
|
|
for (
|
|
;
|
|
s &&
|
|
s !==
|
|
`
|
|
` &&
|
|
s !== '#';
|
|
|
|
)
|
|
s = n[(r += 1)];
|
|
return (this.valueRange = new u.Range(e, r)), r;
|
|
}
|
|
parse(e, n) {
|
|
this.context = e;
|
|
let r = this.parseName(n + 1);
|
|
return (
|
|
(r = this.parseParameters(r)),
|
|
(r = this.parseComment(r)),
|
|
(this.range = new u.Range(n, r)),
|
|
r
|
|
);
|
|
}
|
|
},
|
|
_n = class t extends u.Node {
|
|
static startCommentOrEndBlankLine(e, n) {
|
|
let r = u.Node.endOfWhiteSpace(e, n),
|
|
s = e[r];
|
|
return (
|
|
s === '#' ||
|
|
s ===
|
|
`
|
|
`
|
|
) ?
|
|
r
|
|
: n;
|
|
}
|
|
constructor() {
|
|
super(u.Type.DOCUMENT),
|
|
(this.directives = null),
|
|
(this.contents = null),
|
|
(this.directivesEndMarker = null),
|
|
(this.documentEndMarker = null);
|
|
}
|
|
parseDirectives(e) {
|
|
let { src: n } = this.context;
|
|
this.directives = [];
|
|
let r = !0,
|
|
s = !1,
|
|
i = e;
|
|
for (; !u.Node.atDocumentBoundary(n, i, u.Char.DIRECTIVES_END); )
|
|
switch (((i = t.startCommentOrEndBlankLine(n, i)), n[i])) {
|
|
case `
|
|
`:
|
|
if (r) {
|
|
let o = new Se();
|
|
(i = o.parse({ src: n }, i)),
|
|
i < n.length && this.directives.push(o);
|
|
} else (i += 1), (r = !0);
|
|
break;
|
|
case '#':
|
|
{
|
|
let o = new Ee();
|
|
(i = o.parse({ src: n }, i)),
|
|
this.directives.push(o),
|
|
(r = !1);
|
|
}
|
|
break;
|
|
case '%':
|
|
{
|
|
let o = new Pn();
|
|
(i = o.parse({ parent: this, src: n }, i)),
|
|
this.directives.push(o),
|
|
(s = !0),
|
|
(r = !1);
|
|
}
|
|
break;
|
|
default:
|
|
return (
|
|
s ?
|
|
(this.error = new u.YAMLSemanticError(
|
|
this,
|
|
'Missing directives-end indicator line'
|
|
))
|
|
: this.directives.length > 0 &&
|
|
((this.contents = this.directives), (this.directives = [])),
|
|
i
|
|
);
|
|
}
|
|
return n[i] ?
|
|
((this.directivesEndMarker = new u.Range(i, i + 3)), i + 3)
|
|
: (s ?
|
|
(this.error = new u.YAMLSemanticError(
|
|
this,
|
|
'Missing directives-end indicator line'
|
|
))
|
|
: this.directives.length > 0 &&
|
|
((this.contents = this.directives), (this.directives = [])),
|
|
i);
|
|
}
|
|
parseContents(e) {
|
|
let { parseNode: n, src: r } = this.context;
|
|
this.contents || (this.contents = []);
|
|
let s = e;
|
|
for (; r[s - 1] === '-'; ) s -= 1;
|
|
let i = u.Node.endOfWhiteSpace(r, e),
|
|
o = s === e;
|
|
for (
|
|
this.valueRange = new u.Range(i);
|
|
!u.Node.atDocumentBoundary(r, i, u.Char.DOCUMENT_END);
|
|
|
|
) {
|
|
switch (r[i]) {
|
|
case `
|
|
`:
|
|
if (o) {
|
|
let a = new Se();
|
|
(i = a.parse({ src: r }, i)),
|
|
i < r.length && this.contents.push(a);
|
|
} else (i += 1), (o = !0);
|
|
s = i;
|
|
break;
|
|
case '#':
|
|
{
|
|
let a = new Ee();
|
|
(i = a.parse({ src: r }, i)), this.contents.push(a), (o = !1);
|
|
}
|
|
break;
|
|
default: {
|
|
let a = u.Node.endOfIndent(r, i),
|
|
l = n(
|
|
{
|
|
atLineStart: o,
|
|
indent: -1,
|
|
inFlow: !1,
|
|
inCollection: !1,
|
|
lineStart: s,
|
|
parent: this,
|
|
},
|
|
a
|
|
);
|
|
if (!l) return (this.valueRange.end = a);
|
|
this.contents.push(l), (i = l.range.end), (o = !1);
|
|
let f = In(l);
|
|
f && Array.prototype.push.apply(this.contents, f);
|
|
}
|
|
}
|
|
i = t.startCommentOrEndBlankLine(r, i);
|
|
}
|
|
if (
|
|
((this.valueRange.end = i),
|
|
r[i] &&
|
|
((this.documentEndMarker = new u.Range(i, i + 3)),
|
|
(i += 3),
|
|
r[i]))
|
|
) {
|
|
if (((i = u.Node.endOfWhiteSpace(r, i)), r[i] === '#')) {
|
|
let a = new Ee();
|
|
(i = a.parse({ src: r }, i)), this.contents.push(a);
|
|
}
|
|
switch (r[i]) {
|
|
case `
|
|
`:
|
|
i += 1;
|
|
break;
|
|
case void 0:
|
|
break;
|
|
default:
|
|
this.error = new u.YAMLSyntaxError(
|
|
this,
|
|
'Document end marker line cannot have a non-comment suffix'
|
|
);
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
parse(e, n) {
|
|
(e.root = this), (this.context = e);
|
|
let { src: r } = e,
|
|
s = r.charCodeAt(n) === 65279 ? n + 1 : n;
|
|
return (s = this.parseDirectives(s)), (s = this.parseContents(s)), s;
|
|
}
|
|
setOrigRanges(e, n) {
|
|
return (
|
|
(n = super.setOrigRanges(e, n)),
|
|
this.directives.forEach((r) => {
|
|
n = r.setOrigRanges(e, n);
|
|
}),
|
|
this.directivesEndMarker &&
|
|
(n = this.directivesEndMarker.setOrigRange(e, n)),
|
|
this.contents.forEach((r) => {
|
|
n = r.setOrigRanges(e, n);
|
|
}),
|
|
this.documentEndMarker &&
|
|
(n = this.documentEndMarker.setOrigRange(e, n)),
|
|
n
|
|
);
|
|
}
|
|
toString() {
|
|
let { contents: e, directives: n, value: r } = this;
|
|
if (r != null) return r;
|
|
let s = n.join('');
|
|
return (
|
|
e.length > 0 &&
|
|
((n.length > 0 || e[0].type === u.Type.COMMENT) &&
|
|
(s += `---
|
|
`),
|
|
(s += e.join(''))),
|
|
s[s.length - 1] !==
|
|
`
|
|
` &&
|
|
(s += `
|
|
`),
|
|
s
|
|
);
|
|
}
|
|
},
|
|
xn = class extends u.Node {
|
|
parse(e, n) {
|
|
this.context = e;
|
|
let { src: r } = e,
|
|
s = u.Node.endOfIdentifier(r, n + 1);
|
|
return (
|
|
(this.valueRange = new u.Range(n + 1, s)),
|
|
(s = u.Node.endOfWhiteSpace(r, s)),
|
|
(s = this.parseComment(s)),
|
|
s
|
|
);
|
|
}
|
|
},
|
|
fe = { CLIP: 'CLIP', KEEP: 'KEEP', STRIP: 'STRIP' },
|
|
Rn = class extends u.Node {
|
|
constructor(e, n) {
|
|
super(e, n),
|
|
(this.blockIndent = null),
|
|
(this.chomping = fe.CLIP),
|
|
(this.header = null);
|
|
}
|
|
get includesTrailingLines() {
|
|
return this.chomping === fe.KEEP;
|
|
}
|
|
get strValue() {
|
|
if (!this.valueRange || !this.context) return null;
|
|
let { start: e, end: n } = this.valueRange,
|
|
{ indent: r, src: s } = this.context;
|
|
if (this.valueRange.isEmpty()) return '';
|
|
let i = null,
|
|
o = s[n - 1];
|
|
for (
|
|
;
|
|
o ===
|
|
`
|
|
` ||
|
|
o === ' ' ||
|
|
o === ' ';
|
|
|
|
) {
|
|
if (((n -= 1), n <= e)) {
|
|
if (this.chomping === fe.KEEP) break;
|
|
return '';
|
|
}
|
|
o ===
|
|
`
|
|
` && (i = n),
|
|
(o = s[n - 1]);
|
|
}
|
|
let a = n + 1;
|
|
i &&
|
|
(this.chomping === fe.KEEP ?
|
|
((a = i), (n = this.valueRange.end))
|
|
: (n = i));
|
|
let c = r + this.blockIndent,
|
|
l = this.type === u.Type.BLOCK_FOLDED,
|
|
f = !0,
|
|
m = '',
|
|
d = '',
|
|
y = !1;
|
|
for (let h = e; h < n; ++h) {
|
|
for (let w = 0; w < c && s[h] === ' '; ++w) h += 1;
|
|
let g = s[h];
|
|
if (
|
|
g ===
|
|
`
|
|
`
|
|
)
|
|
(
|
|
d ===
|
|
`
|
|
`
|
|
) ?
|
|
(m += `
|
|
`)
|
|
: (d = `
|
|
`);
|
|
else {
|
|
let w = u.Node.endOfLine(s, h),
|
|
C = s.slice(h, w);
|
|
(h = w),
|
|
l && (g === ' ' || g === ' ') && h < a ?
|
|
(d === ' ' ?
|
|
(d = `
|
|
`)
|
|
: !y &&
|
|
!f &&
|
|
d ===
|
|
`
|
|
` &&
|
|
(d = `
|
|
|
|
`),
|
|
(m += d + C),
|
|
(d = (w < n && s[w]) || ''),
|
|
(y = !0))
|
|
: ((m += d + C),
|
|
(d =
|
|
l && h < a ?
|
|
' '
|
|
: `
|
|
`),
|
|
(y = !1)),
|
|
f && C !== '' && (f = !1);
|
|
}
|
|
}
|
|
return this.chomping === fe.STRIP ?
|
|
m
|
|
: m +
|
|
`
|
|
`;
|
|
}
|
|
parseBlockHeader(e) {
|
|
let { src: n } = this.context,
|
|
r = e + 1,
|
|
s = '';
|
|
for (;;) {
|
|
let i = n[r];
|
|
switch (i) {
|
|
case '-':
|
|
this.chomping = fe.STRIP;
|
|
break;
|
|
case '+':
|
|
this.chomping = fe.KEEP;
|
|
break;
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
s += i;
|
|
break;
|
|
default:
|
|
return (
|
|
(this.blockIndent = Number(s) || null),
|
|
(this.header = new u.Range(e, r)),
|
|
r
|
|
);
|
|
}
|
|
r += 1;
|
|
}
|
|
}
|
|
parseBlockValue(e) {
|
|
let { indent: n, src: r } = this.context,
|
|
s = !!this.blockIndent,
|
|
i = e,
|
|
o = e,
|
|
a = 1;
|
|
for (
|
|
let c = r[i];
|
|
c ===
|
|
`
|
|
` && ((i += 1), !u.Node.atDocumentBoundary(r, i));
|
|
c = r[i]
|
|
) {
|
|
let l = u.Node.endOfBlockIndent(r, n, i);
|
|
if (l === null) break;
|
|
let f = r[l],
|
|
m = l - (i + n);
|
|
if (this.blockIndent) {
|
|
if (
|
|
f &&
|
|
f !==
|
|
`
|
|
` &&
|
|
m < this.blockIndent
|
|
) {
|
|
if (r[l] === '#') break;
|
|
if (!this.error) {
|
|
let y = `Block scalars must not be less indented than their ${s ? 'explicit indentation indicator' : 'first line'}`;
|
|
this.error = new u.YAMLSemanticError(this, y);
|
|
}
|
|
}
|
|
} else if (
|
|
r[l] !==
|
|
`
|
|
`
|
|
) {
|
|
if (m < a) {
|
|
let d =
|
|
'Block scalars with more-indented leading empty lines must use an explicit indentation indicator';
|
|
this.error = new u.YAMLSemanticError(this, d);
|
|
}
|
|
this.blockIndent = m;
|
|
} else m > a && (a = m);
|
|
(
|
|
r[l] ===
|
|
`
|
|
`
|
|
) ?
|
|
(i = l)
|
|
: (i = o = u.Node.endOfLine(r, l));
|
|
}
|
|
return (
|
|
this.chomping !== fe.KEEP && (i = r[o] ? o + 1 : o),
|
|
(this.valueRange = new u.Range(e + 1, i)),
|
|
i
|
|
);
|
|
}
|
|
parse(e, n) {
|
|
this.context = e;
|
|
let { src: r } = e,
|
|
s = this.parseBlockHeader(n);
|
|
return (
|
|
(s = u.Node.endOfWhiteSpace(r, s)),
|
|
(s = this.parseComment(s)),
|
|
(s = this.parseBlockValue(s)),
|
|
s
|
|
);
|
|
}
|
|
setOrigRanges(e, n) {
|
|
return (
|
|
(n = super.setOrigRanges(e, n)),
|
|
this.header ? this.header.setOrigRange(e, n) : n
|
|
);
|
|
}
|
|
},
|
|
Dn = class extends u.Node {
|
|
constructor(e, n) {
|
|
super(e, n), (this.items = null);
|
|
}
|
|
prevNodeIsJsonLike(e = this.items.length) {
|
|
let n = this.items[e - 1];
|
|
return (
|
|
!!n &&
|
|
(n.jsonLike ||
|
|
(n.type === u.Type.COMMENT && this.prevNodeIsJsonLike(e - 1)))
|
|
);
|
|
}
|
|
parse(e, n) {
|
|
this.context = e;
|
|
let { parseNode: r, src: s } = e,
|
|
{ indent: i, lineStart: o } = e,
|
|
a = s[n];
|
|
this.items = [{ char: a, offset: n }];
|
|
let c = u.Node.endOfWhiteSpace(s, n + 1);
|
|
for (a = s[c]; a && a !== ']' && a !== '}'; ) {
|
|
switch (a) {
|
|
case `
|
|
`:
|
|
{
|
|
o = c + 1;
|
|
let l = u.Node.endOfWhiteSpace(s, o);
|
|
if (
|
|
s[l] ===
|
|
`
|
|
`
|
|
) {
|
|
let f = new Se();
|
|
(o = f.parse({ src: s }, o)), this.items.push(f);
|
|
}
|
|
if (
|
|
((c = u.Node.endOfIndent(s, o)),
|
|
c <= o + i &&
|
|
((a = s[c]), c < o + i || (a !== ']' && a !== '}')))
|
|
) {
|
|
let f = 'Insufficient indentation in flow collection';
|
|
this.error = new u.YAMLSemanticError(this, f);
|
|
}
|
|
}
|
|
break;
|
|
case ',':
|
|
this.items.push({ char: a, offset: c }), (c += 1);
|
|
break;
|
|
case '#':
|
|
{
|
|
let l = new Ee();
|
|
(c = l.parse({ src: s }, c)), this.items.push(l);
|
|
}
|
|
break;
|
|
case '?':
|
|
case ':': {
|
|
let l = s[c + 1];
|
|
if (
|
|
l ===
|
|
`
|
|
` ||
|
|
l === ' ' ||
|
|
l === ' ' ||
|
|
l === ',' ||
|
|
(a === ':' && this.prevNodeIsJsonLike())
|
|
) {
|
|
this.items.push({ char: a, offset: c }), (c += 1);
|
|
break;
|
|
}
|
|
}
|
|
default: {
|
|
let l = r(
|
|
{
|
|
atLineStart: !1,
|
|
inCollection: !1,
|
|
inFlow: !0,
|
|
indent: -1,
|
|
lineStart: o,
|
|
parent: this,
|
|
},
|
|
c
|
|
);
|
|
if (!l) return (this.valueRange = new u.Range(n, c)), c;
|
|
this.items.push(l),
|
|
(c = u.Node.normalizeOffset(s, l.range.end));
|
|
}
|
|
}
|
|
(c = u.Node.endOfWhiteSpace(s, c)), (a = s[c]);
|
|
}
|
|
return (
|
|
(this.valueRange = new u.Range(n, c + 1)),
|
|
a &&
|
|
(this.items.push({ char: a, offset: c }),
|
|
(c = u.Node.endOfWhiteSpace(s, c + 1)),
|
|
(c = this.parseComment(c))),
|
|
c
|
|
);
|
|
}
|
|
setOrigRanges(e, n) {
|
|
return (
|
|
(n = super.setOrigRanges(e, n)),
|
|
this.items.forEach((r) => {
|
|
if (r instanceof u.Node) n = r.setOrigRanges(e, n);
|
|
else if (e.length === 0) r.origOffset = r.offset;
|
|
else {
|
|
let s = n;
|
|
for (; s < e.length && !(e[s] > r.offset); ) ++s;
|
|
(r.origOffset = r.offset + s), (n = s);
|
|
}
|
|
}),
|
|
n
|
|
);
|
|
}
|
|
toString() {
|
|
let {
|
|
context: { src: e },
|
|
items: n,
|
|
range: r,
|
|
value: s,
|
|
} = this;
|
|
if (s != null) return s;
|
|
let i = n.filter((c) => c instanceof u.Node),
|
|
o = '',
|
|
a = r.start;
|
|
return (
|
|
i.forEach((c) => {
|
|
let l = e.slice(a, c.range.start);
|
|
(a = c.range.end),
|
|
(o += l + String(c)),
|
|
o[o.length - 1] ===
|
|
`
|
|
` &&
|
|
e[a - 1] !==
|
|
`
|
|
` &&
|
|
e[a] ===
|
|
`
|
|
` &&
|
|
(a += 1);
|
|
}),
|
|
(o += e.slice(a, r.end)),
|
|
u.Node.addStringTerminator(e, r.end, o)
|
|
);
|
|
}
|
|
},
|
|
Yn = class t extends u.Node {
|
|
static endOfQuote(e, n) {
|
|
let r = e[n];
|
|
for (; r && r !== '"'; ) (n += r === '\\' ? 2 : 1), (r = e[n]);
|
|
return n + 1;
|
|
}
|
|
get strValue() {
|
|
if (!this.valueRange || !this.context) return null;
|
|
let e = [],
|
|
{ start: n, end: r } = this.valueRange,
|
|
{ indent: s, src: i } = this.context;
|
|
i[r - 1] !== '"' &&
|
|
e.push(new u.YAMLSyntaxError(this, 'Missing closing "quote'));
|
|
let o = '';
|
|
for (let a = n + 1; a < r - 1; ++a) {
|
|
let c = i[a];
|
|
if (
|
|
c ===
|
|
`
|
|
`
|
|
) {
|
|
u.Node.atDocumentBoundary(i, a + 1) &&
|
|
e.push(
|
|
new u.YAMLSemanticError(
|
|
this,
|
|
'Document boundary indicators are not allowed within string values'
|
|
)
|
|
);
|
|
let {
|
|
fold: l,
|
|
offset: f,
|
|
error: m,
|
|
} = u.Node.foldNewline(i, a, s);
|
|
(o += l),
|
|
(a = f),
|
|
m &&
|
|
e.push(
|
|
new u.YAMLSemanticError(
|
|
this,
|
|
'Multi-line double-quoted string needs to be sufficiently indented'
|
|
)
|
|
);
|
|
} else if (c === '\\')
|
|
switch (((a += 1), i[a])) {
|
|
case '0':
|
|
o += '\0';
|
|
break;
|
|
case 'a':
|
|
o += '\x07';
|
|
break;
|
|
case 'b':
|
|
o += '\b';
|
|
break;
|
|
case 'e':
|
|
o += '\x1B';
|
|
break;
|
|
case 'f':
|
|
o += '\f';
|
|
break;
|
|
case 'n':
|
|
o += `
|
|
`;
|
|
break;
|
|
case 'r':
|
|
o += '\r';
|
|
break;
|
|
case 't':
|
|
o += ' ';
|
|
break;
|
|
case 'v':
|
|
o += '\v';
|
|
break;
|
|
case 'N':
|
|
o += '\x85';
|
|
break;
|
|
case '_':
|
|
o += '\xA0';
|
|
break;
|
|
case 'L':
|
|
o += '\u2028';
|
|
break;
|
|
case 'P':
|
|
o += '\u2029';
|
|
break;
|
|
case ' ':
|
|
o += ' ';
|
|
break;
|
|
case '"':
|
|
o += '"';
|
|
break;
|
|
case '/':
|
|
o += '/';
|
|
break;
|
|
case '\\':
|
|
o += '\\';
|
|
break;
|
|
case ' ':
|
|
o += ' ';
|
|
break;
|
|
case 'x':
|
|
(o += this.parseCharCode(a + 1, 2, e)), (a += 2);
|
|
break;
|
|
case 'u':
|
|
(o += this.parseCharCode(a + 1, 4, e)), (a += 4);
|
|
break;
|
|
case 'U':
|
|
(o += this.parseCharCode(a + 1, 8, e)), (a += 8);
|
|
break;
|
|
case `
|
|
`:
|
|
for (; i[a + 1] === ' ' || i[a + 1] === ' '; ) a += 1;
|
|
break;
|
|
default:
|
|
e.push(
|
|
new u.YAMLSyntaxError(
|
|
this,
|
|
`Invalid escape sequence ${i.substr(a - 1, 2)}`
|
|
)
|
|
),
|
|
(o += '\\' + i[a]);
|
|
}
|
|
else if (c === ' ' || c === ' ') {
|
|
let l = a,
|
|
f = i[a + 1];
|
|
for (; f === ' ' || f === ' '; ) (a += 1), (f = i[a + 1]);
|
|
f !==
|
|
`
|
|
` && (o += a > l ? i.slice(l, a + 1) : c);
|
|
} else o += c;
|
|
}
|
|
return e.length > 0 ? { errors: e, str: o } : o;
|
|
}
|
|
parseCharCode(e, n, r) {
|
|
let { src: s } = this.context,
|
|
i = s.substr(e, n),
|
|
a =
|
|
i.length === n && /^[0-9a-fA-F]+$/.test(i) ?
|
|
parseInt(i, 16)
|
|
: NaN;
|
|
return isNaN(a) ?
|
|
(r.push(
|
|
new u.YAMLSyntaxError(
|
|
this,
|
|
`Invalid escape sequence ${s.substr(e - 2, n + 2)}`
|
|
)
|
|
),
|
|
s.substr(e - 2, n + 2))
|
|
: String.fromCodePoint(a);
|
|
}
|
|
parse(e, n) {
|
|
this.context = e;
|
|
let { src: r } = e,
|
|
s = t.endOfQuote(r, n + 1);
|
|
return (
|
|
(this.valueRange = new u.Range(n, s)),
|
|
(s = u.Node.endOfWhiteSpace(r, s)),
|
|
(s = this.parseComment(s)),
|
|
s
|
|
);
|
|
}
|
|
},
|
|
$n = class t extends u.Node {
|
|
static endOfQuote(e, n) {
|
|
let r = e[n];
|
|
for (; r; )
|
|
if (r === "'") {
|
|
if (e[n + 1] !== "'") break;
|
|
r = e[(n += 2)];
|
|
} else r = e[(n += 1)];
|
|
return n + 1;
|
|
}
|
|
get strValue() {
|
|
if (!this.valueRange || !this.context) return null;
|
|
let e = [],
|
|
{ start: n, end: r } = this.valueRange,
|
|
{ indent: s, src: i } = this.context;
|
|
i[r - 1] !== "'" &&
|
|
e.push(new u.YAMLSyntaxError(this, "Missing closing 'quote"));
|
|
let o = '';
|
|
for (let a = n + 1; a < r - 1; ++a) {
|
|
let c = i[a];
|
|
if (
|
|
c ===
|
|
`
|
|
`
|
|
) {
|
|
u.Node.atDocumentBoundary(i, a + 1) &&
|
|
e.push(
|
|
new u.YAMLSemanticError(
|
|
this,
|
|
'Document boundary indicators are not allowed within string values'
|
|
)
|
|
);
|
|
let {
|
|
fold: l,
|
|
offset: f,
|
|
error: m,
|
|
} = u.Node.foldNewline(i, a, s);
|
|
(o += l),
|
|
(a = f),
|
|
m &&
|
|
e.push(
|
|
new u.YAMLSemanticError(
|
|
this,
|
|
'Multi-line single-quoted string needs to be sufficiently indented'
|
|
)
|
|
);
|
|
} else if (c === "'")
|
|
(o += c),
|
|
(a += 1),
|
|
i[a] !== "'" &&
|
|
e.push(
|
|
new u.YAMLSyntaxError(
|
|
this,
|
|
'Unescaped single quote? This should not happen.'
|
|
)
|
|
);
|
|
else if (c === ' ' || c === ' ') {
|
|
let l = a,
|
|
f = i[a + 1];
|
|
for (; f === ' ' || f === ' '; ) (a += 1), (f = i[a + 1]);
|
|
f !==
|
|
`
|
|
` && (o += a > l ? i.slice(l, a + 1) : c);
|
|
} else o += c;
|
|
}
|
|
return e.length > 0 ? { errors: e, str: o } : o;
|
|
}
|
|
parse(e, n) {
|
|
this.context = e;
|
|
let { src: r } = e,
|
|
s = t.endOfQuote(r, n + 1);
|
|
return (
|
|
(this.valueRange = new u.Range(n, s)),
|
|
(s = u.Node.endOfWhiteSpace(r, s)),
|
|
(s = this.parseComment(s)),
|
|
s
|
|
);
|
|
}
|
|
};
|
|
function vo(t, e) {
|
|
switch (t) {
|
|
case u.Type.ALIAS:
|
|
return new xn(t, e);
|
|
case u.Type.BLOCK_FOLDED:
|
|
case u.Type.BLOCK_LITERAL:
|
|
return new Rn(t, e);
|
|
case u.Type.FLOW_MAP:
|
|
case u.Type.FLOW_SEQ:
|
|
return new Dn(t, e);
|
|
case u.Type.MAP_KEY:
|
|
case u.Type.MAP_VALUE:
|
|
case u.Type.SEQ_ITEM:
|
|
return new ut(t, e);
|
|
case u.Type.COMMENT:
|
|
case u.Type.PLAIN:
|
|
return new u.PlainValue(t, e);
|
|
case u.Type.QUOTE_DOUBLE:
|
|
return new Yn(t, e);
|
|
case u.Type.QUOTE_SINGLE:
|
|
return new $n(t, e);
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
var Bn = class t {
|
|
static parseType(e, n, r) {
|
|
switch (e[n]) {
|
|
case '*':
|
|
return u.Type.ALIAS;
|
|
case '>':
|
|
return u.Type.BLOCK_FOLDED;
|
|
case '|':
|
|
return u.Type.BLOCK_LITERAL;
|
|
case '{':
|
|
return u.Type.FLOW_MAP;
|
|
case '[':
|
|
return u.Type.FLOW_SEQ;
|
|
case '?':
|
|
return !r && u.Node.atBlank(e, n + 1, !0) ?
|
|
u.Type.MAP_KEY
|
|
: u.Type.PLAIN;
|
|
case ':':
|
|
return !r && u.Node.atBlank(e, n + 1, !0) ?
|
|
u.Type.MAP_VALUE
|
|
: u.Type.PLAIN;
|
|
case '-':
|
|
return !r && u.Node.atBlank(e, n + 1, !0) ?
|
|
u.Type.SEQ_ITEM
|
|
: u.Type.PLAIN;
|
|
case '"':
|
|
return u.Type.QUOTE_DOUBLE;
|
|
case "'":
|
|
return u.Type.QUOTE_SINGLE;
|
|
default:
|
|
return u.Type.PLAIN;
|
|
}
|
|
}
|
|
constructor(
|
|
e = {},
|
|
{
|
|
atLineStart: n,
|
|
inCollection: r,
|
|
inFlow: s,
|
|
indent: i,
|
|
lineStart: o,
|
|
parent: a,
|
|
} = {}
|
|
) {
|
|
u._defineProperty(this, 'parseNode', (c, l) => {
|
|
if (u.Node.atDocumentBoundary(this.src, l)) return null;
|
|
let f = new t(this, c),
|
|
{ props: m, type: d, valueStart: y } = f.parseProps(l),
|
|
h = vo(d, m),
|
|
g = h.parse(f, y);
|
|
if (
|
|
((h.range = new u.Range(l, g)),
|
|
g <= l &&
|
|
((h.error = new Error('Node#parse consumed no characters')),
|
|
(h.error.parseEnd = g),
|
|
(h.error.source = h),
|
|
(h.range.end = l + 1)),
|
|
f.nodeStartsCollection(h))
|
|
) {
|
|
!h.error &&
|
|
!f.atLineStart &&
|
|
f.parent.type === u.Type.DOCUMENT &&
|
|
(h.error = new u.YAMLSyntaxError(
|
|
h,
|
|
'Block collection must not have preceding content here (e.g. directives-end indicator)'
|
|
));
|
|
let w = new Bt(h);
|
|
return (g = w.parse(new t(f), g)), (w.range = new u.Range(l, g)), w;
|
|
}
|
|
return h;
|
|
}),
|
|
(this.atLineStart = n ?? (e.atLineStart || !1)),
|
|
(this.inCollection = r ?? (e.inCollection || !1)),
|
|
(this.inFlow = s ?? (e.inFlow || !1)),
|
|
(this.indent = i ?? e.indent),
|
|
(this.lineStart = o ?? e.lineStart),
|
|
(this.parent = a ?? (e.parent || {})),
|
|
(this.root = e.root),
|
|
(this.src = e.src);
|
|
}
|
|
nodeStartsCollection(e) {
|
|
let { inCollection: n, inFlow: r, src: s } = this;
|
|
if (n || r) return !1;
|
|
if (e instanceof ut) return !0;
|
|
let i = e.range.end;
|
|
return (
|
|
s[i] ===
|
|
`
|
|
` ||
|
|
s[i - 1] ===
|
|
`
|
|
`
|
|
) ?
|
|
!1
|
|
: ((i = u.Node.endOfWhiteSpace(s, i)), s[i] === ':');
|
|
}
|
|
parseProps(e) {
|
|
let { inFlow: n, parent: r, src: s } = this,
|
|
i = [],
|
|
o = !1;
|
|
e =
|
|
this.atLineStart ?
|
|
u.Node.endOfIndent(s, e)
|
|
: u.Node.endOfWhiteSpace(s, e);
|
|
let a = s[e];
|
|
for (
|
|
;
|
|
a === u.Char.ANCHOR ||
|
|
a === u.Char.COMMENT ||
|
|
a === u.Char.TAG ||
|
|
a ===
|
|
`
|
|
`;
|
|
|
|
) {
|
|
if (
|
|
a ===
|
|
`
|
|
`
|
|
) {
|
|
let l = e,
|
|
f;
|
|
do (f = l + 1), (l = u.Node.endOfIndent(s, f));
|
|
while (
|
|
s[l] ===
|
|
`
|
|
`
|
|
);
|
|
let m = l - (f + this.indent),
|
|
d = r.type === u.Type.SEQ_ITEM && r.context.atLineStart;
|
|
if (s[l] !== '#' && !u.Node.nextNodeIsIndented(s[l], m, !d)) break;
|
|
(this.atLineStart = !0), (this.lineStart = f), (o = !1), (e = l);
|
|
} else if (a === u.Char.COMMENT) {
|
|
let l = u.Node.endOfLine(s, e + 1);
|
|
i.push(new u.Range(e, l)), (e = l);
|
|
} else {
|
|
let l = u.Node.endOfIdentifier(s, e + 1);
|
|
a === u.Char.TAG &&
|
|
s[l] === ',' &&
|
|
/^[a-zA-Z0-9-]+\.[a-zA-Z0-9-]+,\d\d\d\d(-\d\d){0,2}\/\S/.test(
|
|
s.slice(e + 1, l + 13)
|
|
) &&
|
|
(l = u.Node.endOfIdentifier(s, l + 5)),
|
|
i.push(new u.Range(e, l)),
|
|
(o = !0),
|
|
(e = u.Node.endOfWhiteSpace(s, l));
|
|
}
|
|
a = s[e];
|
|
}
|
|
o && a === ':' && u.Node.atBlank(s, e + 1, !0) && (e -= 1);
|
|
let c = t.parseType(s, e, n);
|
|
return { props: i, type: c, valueStart: e };
|
|
}
|
|
};
|
|
function Io(t) {
|
|
let e = [];
|
|
t.indexOf('\r') !== -1 &&
|
|
(t = t.replace(
|
|
/\r\n?/g,
|
|
(s, i) => (
|
|
s.length > 1 && e.push(i),
|
|
`
|
|
`
|
|
)
|
|
));
|
|
let n = [],
|
|
r = 0;
|
|
do {
|
|
let s = new _n(),
|
|
i = new Bn({ src: t });
|
|
(r = s.parse(i, r)), n.push(s);
|
|
} while (r < t.length);
|
|
return (
|
|
(n.setOrigRanges = () => {
|
|
if (e.length === 0) return !1;
|
|
for (let i = 1; i < e.length; ++i) e[i] -= i;
|
|
let s = 0;
|
|
for (let i = 0; i < n.length; ++i) s = n[i].setOrigRanges(e, s);
|
|
return e.splice(0, e.length), !0;
|
|
}),
|
|
(n.toString = () =>
|
|
n.join(`...
|
|
`)),
|
|
n
|
|
);
|
|
}
|
|
xs.parse = Io;
|
|
});
|
|
var qe = te((k) => {
|
|
'use strict';
|
|
var p = le();
|
|
function Po(t, e, n) {
|
|
return n ?
|
|
`#${n.replace(/[\s\S]^/gm, `$&${e}#`)}
|
|
${e}${t}`
|
|
: t;
|
|
}
|
|
function Fe(t, e, n) {
|
|
return (
|
|
n ?
|
|
(
|
|
n.indexOf(`
|
|
`) === -1
|
|
) ?
|
|
`${t} #${n}`
|
|
: `${t}
|
|
` + n.replace(/^/gm, `${e || ''}#`)
|
|
: t
|
|
);
|
|
}
|
|
var W = class {};
|
|
function ue(t, e, n) {
|
|
if (Array.isArray(t)) return t.map((r, s) => ue(r, String(s), n));
|
|
if (t && typeof t.toJSON == 'function') {
|
|
let r = n && n.anchors && n.anchors.get(t);
|
|
r &&
|
|
(n.onCreate = (i) => {
|
|
(r.res = i), delete n.onCreate;
|
|
});
|
|
let s = t.toJSON(e, n);
|
|
return r && n.onCreate && n.onCreate(s), s;
|
|
}
|
|
return (!n || !n.keep) && typeof t == 'bigint' ? Number(t) : t;
|
|
}
|
|
var P = class extends W {
|
|
constructor(e) {
|
|
super(), (this.value = e);
|
|
}
|
|
toJSON(e, n) {
|
|
return n && n.keep ? this.value : ue(this.value, e, n);
|
|
}
|
|
toString() {
|
|
return String(this.value);
|
|
}
|
|
};
|
|
function Ds(t, e, n) {
|
|
let r = n;
|
|
for (let s = e.length - 1; s >= 0; --s) {
|
|
let i = e[s];
|
|
if (Number.isInteger(i) && i >= 0) {
|
|
let o = [];
|
|
(o[i] = r), (r = o);
|
|
} else {
|
|
let o = {};
|
|
Object.defineProperty(o, i, {
|
|
value: r,
|
|
writable: !0,
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
}),
|
|
(r = o);
|
|
}
|
|
}
|
|
return t.createNode(r, !1);
|
|
}
|
|
var Bs = (t) =>
|
|
t == null || (typeof t == 'object' && t[Symbol.iterator]().next().done),
|
|
j = class t extends W {
|
|
constructor(e) {
|
|
super(), p._defineProperty(this, 'items', []), (this.schema = e);
|
|
}
|
|
addIn(e, n) {
|
|
if (Bs(e)) this.add(n);
|
|
else {
|
|
let [r, ...s] = e,
|
|
i = this.get(r, !0);
|
|
if (i instanceof t) i.addIn(s, n);
|
|
else if (i === void 0 && this.schema)
|
|
this.set(r, Ds(this.schema, s, n));
|
|
else
|
|
throw new Error(
|
|
`Expected YAML collection at ${r}. Remaining path: ${s}`
|
|
);
|
|
}
|
|
}
|
|
deleteIn([e, ...n]) {
|
|
if (n.length === 0) return this.delete(e);
|
|
let r = this.get(e, !0);
|
|
if (r instanceof t) return r.deleteIn(n);
|
|
throw new Error(
|
|
`Expected YAML collection at ${e}. Remaining path: ${n}`
|
|
);
|
|
}
|
|
getIn([e, ...n], r) {
|
|
let s = this.get(e, !0);
|
|
return (
|
|
n.length === 0 ?
|
|
!r && s instanceof P ?
|
|
s.value
|
|
: s
|
|
: s instanceof t ? s.getIn(n, r)
|
|
: void 0
|
|
);
|
|
}
|
|
hasAllNullValues() {
|
|
return this.items.every((e) => {
|
|
if (!e || e.type !== 'PAIR') return !1;
|
|
let n = e.value;
|
|
return (
|
|
n == null ||
|
|
(n instanceof P &&
|
|
n.value == null &&
|
|
!n.commentBefore &&
|
|
!n.comment &&
|
|
!n.tag)
|
|
);
|
|
});
|
|
}
|
|
hasIn([e, ...n]) {
|
|
if (n.length === 0) return this.has(e);
|
|
let r = this.get(e, !0);
|
|
return r instanceof t ? r.hasIn(n) : !1;
|
|
}
|
|
setIn([e, ...n], r) {
|
|
if (n.length === 0) this.set(e, r);
|
|
else {
|
|
let s = this.get(e, !0);
|
|
if (s instanceof t) s.setIn(n, r);
|
|
else if (s === void 0 && this.schema)
|
|
this.set(e, Ds(this.schema, n, r));
|
|
else
|
|
throw new Error(
|
|
`Expected YAML collection at ${e}. Remaining path: ${n}`
|
|
);
|
|
}
|
|
}
|
|
toJSON() {
|
|
return null;
|
|
}
|
|
toString(
|
|
e,
|
|
{ blockItem: n, flowChars: r, isMap: s, itemIndent: i },
|
|
o,
|
|
a
|
|
) {
|
|
let { indent: c, indentStep: l, stringify: f } = e,
|
|
m =
|
|
this.type === p.Type.FLOW_MAP ||
|
|
this.type === p.Type.FLOW_SEQ ||
|
|
e.inFlow;
|
|
m && (i += l);
|
|
let d = s && this.hasAllNullValues();
|
|
e = Object.assign({}, e, {
|
|
allNullValues: d,
|
|
indent: i,
|
|
inFlow: m,
|
|
type: null,
|
|
});
|
|
let y = !1,
|
|
h = !1,
|
|
g = this.items.reduce((C, L, M) => {
|
|
let A;
|
|
L &&
|
|
(!y && L.spaceBefore && C.push({ type: 'comment', str: '' }),
|
|
L.commentBefore &&
|
|
L.commentBefore.match(/^.*$/gm).forEach((Ai) => {
|
|
C.push({ type: 'comment', str: `#${Ai}` });
|
|
}),
|
|
L.comment && (A = L.comment),
|
|
m &&
|
|
((!y && L.spaceBefore) ||
|
|
L.commentBefore ||
|
|
L.comment ||
|
|
(L.key && (L.key.commentBefore || L.key.comment)) ||
|
|
(L.value && (L.value.commentBefore || L.value.comment))) &&
|
|
(h = !0)),
|
|
(y = !1);
|
|
let _ = f(
|
|
L,
|
|
e,
|
|
() => (A = null),
|
|
() => (y = !0)
|
|
);
|
|
return (
|
|
m &&
|
|
!h &&
|
|
_.includes(`
|
|
`) &&
|
|
(h = !0),
|
|
m && M < this.items.length - 1 && (_ += ','),
|
|
(_ = Fe(_, i, A)),
|
|
y && (A || m) && (y = !1),
|
|
C.push({ type: 'item', str: _ }),
|
|
C
|
|
);
|
|
}, []),
|
|
w;
|
|
if (g.length === 0) w = r.start + r.end;
|
|
else if (m) {
|
|
let { start: C, end: L } = r,
|
|
M = g.map((A) => A.str);
|
|
if (
|
|
h ||
|
|
M.reduce((A, _) => A + _.length + 2, 2) >
|
|
t.maxFlowStringSingleLineLength
|
|
) {
|
|
w = C;
|
|
for (let A of M)
|
|
w +=
|
|
A ?
|
|
`
|
|
${l}${c}${A}`
|
|
: `
|
|
`;
|
|
w += `
|
|
${c}${L}`;
|
|
} else w = `${C} ${M.join(' ')} ${L}`;
|
|
} else {
|
|
let C = g.map(n);
|
|
w = C.shift();
|
|
for (let L of C)
|
|
w +=
|
|
L ?
|
|
`
|
|
${c}${L}`
|
|
: `
|
|
`;
|
|
}
|
|
return (
|
|
this.comment ?
|
|
((w +=
|
|
`
|
|
` + this.comment.replace(/^/gm, `${c}#`)),
|
|
o && o())
|
|
: y && a && a(),
|
|
w
|
|
);
|
|
}
|
|
};
|
|
p._defineProperty(j, 'maxFlowStringSingleLineLength', 60);
|
|
function Ft(t) {
|
|
let e = t instanceof P ? t.value : t;
|
|
return (
|
|
e && typeof e == 'string' && (e = Number(e)),
|
|
Number.isInteger(e) && e >= 0 ? e : null
|
|
);
|
|
}
|
|
var pe = class extends j {
|
|
add(e) {
|
|
this.items.push(e);
|
|
}
|
|
delete(e) {
|
|
let n = Ft(e);
|
|
return typeof n != 'number' ? !1 : this.items.splice(n, 1).length > 0;
|
|
}
|
|
get(e, n) {
|
|
let r = Ft(e);
|
|
if (typeof r != 'number') return;
|
|
let s = this.items[r];
|
|
return !n && s instanceof P ? s.value : s;
|
|
}
|
|
has(e) {
|
|
let n = Ft(e);
|
|
return typeof n == 'number' && n < this.items.length;
|
|
}
|
|
set(e, n) {
|
|
let r = Ft(e);
|
|
if (typeof r != 'number')
|
|
throw new Error(`Expected a valid index, not ${e}.`);
|
|
this.items[r] = n;
|
|
}
|
|
toJSON(e, n) {
|
|
let r = [];
|
|
n && n.onCreate && n.onCreate(r);
|
|
let s = 0;
|
|
for (let i of this.items) r.push(ue(i, String(s++), n));
|
|
return r;
|
|
}
|
|
toString(e, n, r) {
|
|
return e ?
|
|
super.toString(
|
|
e,
|
|
{
|
|
blockItem: (s) =>
|
|
s.type === 'comment' ? s.str : `- ${s.str}`,
|
|
flowChars: { start: '[', end: ']' },
|
|
isMap: !1,
|
|
itemIndent: (e.indent || '') + ' ',
|
|
},
|
|
n,
|
|
r
|
|
)
|
|
: JSON.stringify(this);
|
|
}
|
|
},
|
|
_o = (t, e, n) =>
|
|
e === null ? ''
|
|
: typeof e != 'object' ? String(e)
|
|
: t instanceof W && n && n.doc ?
|
|
t.toString({
|
|
anchors: Object.create(null),
|
|
doc: n.doc,
|
|
indent: '',
|
|
indentStep: n.indentStep,
|
|
inFlow: !0,
|
|
inStringifyKey: !0,
|
|
stringify: n.stringify,
|
|
})
|
|
: JSON.stringify(e),
|
|
T = class t extends W {
|
|
constructor(e, n = null) {
|
|
super(), (this.key = e), (this.value = n), (this.type = t.Type.PAIR);
|
|
}
|
|
get commentBefore() {
|
|
return this.key instanceof W ? this.key.commentBefore : void 0;
|
|
}
|
|
set commentBefore(e) {
|
|
if (
|
|
(this.key == null && (this.key = new P(null)),
|
|
this.key instanceof W)
|
|
)
|
|
this.key.commentBefore = e;
|
|
else {
|
|
let n =
|
|
'Pair.commentBefore is an alias for Pair.key.commentBefore. To set it, the key must be a Node.';
|
|
throw new Error(n);
|
|
}
|
|
}
|
|
addToJSMap(e, n) {
|
|
let r = ue(this.key, '', e);
|
|
if (n instanceof Map) {
|
|
let s = ue(this.value, r, e);
|
|
n.set(r, s);
|
|
} else if (n instanceof Set) n.add(r);
|
|
else {
|
|
let s = _o(this.key, r, e),
|
|
i = ue(this.value, s, e);
|
|
s in n ?
|
|
Object.defineProperty(n, s, {
|
|
value: i,
|
|
writable: !0,
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
})
|
|
: (n[s] = i);
|
|
}
|
|
return n;
|
|
}
|
|
toJSON(e, n) {
|
|
let r = n && n.mapAsMap ? new Map() : {};
|
|
return this.addToJSMap(n, r);
|
|
}
|
|
toString(e, n, r) {
|
|
if (!e || !e.doc) return JSON.stringify(this);
|
|
let { indent: s, indentSeq: i, simpleKeys: o } = e.doc.options,
|
|
{ key: a, value: c } = this,
|
|
l = a instanceof W && a.comment;
|
|
if (o) {
|
|
if (l)
|
|
throw new Error(
|
|
'With simple keys, key nodes cannot have comments'
|
|
);
|
|
if (a instanceof j) {
|
|
let _ =
|
|
'With simple keys, collection cannot be used as a key value';
|
|
throw new Error(_);
|
|
}
|
|
}
|
|
let f =
|
|
!o &&
|
|
(!a ||
|
|
l ||
|
|
(a instanceof W ?
|
|
a instanceof j ||
|
|
a.type === p.Type.BLOCK_FOLDED ||
|
|
a.type === p.Type.BLOCK_LITERAL
|
|
: typeof a == 'object')),
|
|
{ doc: m, indent: d, indentStep: y, stringify: h } = e;
|
|
e = Object.assign({}, e, { implicitKey: !f, indent: d + y });
|
|
let g = !1,
|
|
w = h(
|
|
a,
|
|
e,
|
|
() => (l = null),
|
|
() => (g = !0)
|
|
);
|
|
if (((w = Fe(w, e.indent, l)), !f && w.length > 1024)) {
|
|
if (o)
|
|
throw new Error(
|
|
'With simple keys, single line scalar must not span more than 1024 characters'
|
|
);
|
|
f = !0;
|
|
}
|
|
if (e.allNullValues && !o)
|
|
return (
|
|
this.comment ?
|
|
((w = Fe(w, e.indent, this.comment)), n && n())
|
|
: g && !l && r && r(),
|
|
e.inFlow && !f ? w : `? ${w}`
|
|
);
|
|
(w =
|
|
f ?
|
|
`? ${w}
|
|
${d}:`
|
|
: `${w}:`),
|
|
this.comment && ((w = Fe(w, e.indent, this.comment)), n && n());
|
|
let C = '',
|
|
L = null;
|
|
if (c instanceof W) {
|
|
if (
|
|
(c.spaceBefore &&
|
|
(C = `
|
|
`),
|
|
c.commentBefore)
|
|
) {
|
|
let _ = c.commentBefore.replace(/^/gm, `${e.indent}#`);
|
|
C += `
|
|
${_}`;
|
|
}
|
|
L = c.comment;
|
|
} else c && typeof c == 'object' && (c = m.schema.createNode(c, !0));
|
|
(e.implicitKey = !1),
|
|
!f &&
|
|
!this.comment &&
|
|
c instanceof P &&
|
|
(e.indentAtStart = w.length + 1),
|
|
(g = !1),
|
|
!i &&
|
|
s >= 2 &&
|
|
!e.inFlow &&
|
|
!f &&
|
|
c instanceof pe &&
|
|
c.type !== p.Type.FLOW_SEQ &&
|
|
!c.tag &&
|
|
!m.anchors.getName(c) &&
|
|
(e.indent = e.indent.substr(2));
|
|
let M = h(
|
|
c,
|
|
e,
|
|
() => (L = null),
|
|
() => (g = !0)
|
|
),
|
|
A = ' ';
|
|
return (
|
|
C || this.comment ?
|
|
(A = `${C}
|
|
${e.indent}`)
|
|
: !f && c instanceof j ?
|
|
(!(M[0] === '[' || M[0] === '{') ||
|
|
M.includes(`
|
|
`)) &&
|
|
(A = `
|
|
${e.indent}`)
|
|
: M[0] ===
|
|
`
|
|
` && (A = ''),
|
|
g && !L && r && r(),
|
|
Fe(w + A + M, e.indent, L)
|
|
);
|
|
}
|
|
};
|
|
p._defineProperty(T, 'Type', { PAIR: 'PAIR', MERGE_PAIR: 'MERGE_PAIR' });
|
|
var qt = (t, e) => {
|
|
if (t instanceof be) {
|
|
let n = e.get(t.source);
|
|
return n.count * n.aliasCount;
|
|
} else if (t instanceof j) {
|
|
let n = 0;
|
|
for (let r of t.items) {
|
|
let s = qt(r, e);
|
|
s > n && (n = s);
|
|
}
|
|
return n;
|
|
} else if (t instanceof T) {
|
|
let n = qt(t.key, e),
|
|
r = qt(t.value, e);
|
|
return Math.max(n, r);
|
|
}
|
|
return 1;
|
|
},
|
|
be = class t extends W {
|
|
static stringify(
|
|
{ range: e, source: n },
|
|
{ anchors: r, doc: s, implicitKey: i, inStringifyKey: o }
|
|
) {
|
|
let a = Object.keys(r).find((l) => r[l] === n);
|
|
if ((!a && o && (a = s.anchors.getName(n) || s.anchors.newName()), a))
|
|
return `*${a}${i ? ' ' : ''}`;
|
|
let c =
|
|
s.anchors.getName(n) ?
|
|
'Alias node must be after source node'
|
|
: 'Source node not found for alias node';
|
|
throw new Error(`${c} [${e}]`);
|
|
}
|
|
constructor(e) {
|
|
super(), (this.source = e), (this.type = p.Type.ALIAS);
|
|
}
|
|
set tag(e) {
|
|
throw new Error('Alias nodes cannot have tags');
|
|
}
|
|
toJSON(e, n) {
|
|
if (!n) return ue(this.source, e, n);
|
|
let { anchors: r, maxAliasCount: s } = n,
|
|
i = r.get(this.source);
|
|
if (!i || i.res === void 0) {
|
|
let o = 'This should not happen: Alias anchor was not resolved?';
|
|
throw this.cstNode ?
|
|
new p.YAMLReferenceError(this.cstNode, o)
|
|
: new ReferenceError(o);
|
|
}
|
|
if (
|
|
s >= 0 &&
|
|
((i.count += 1),
|
|
i.aliasCount === 0 && (i.aliasCount = qt(this.source, r)),
|
|
i.count * i.aliasCount > s)
|
|
) {
|
|
let o =
|
|
'Excessive alias count indicates a resource exhaustion attack';
|
|
throw this.cstNode ?
|
|
new p.YAMLReferenceError(this.cstNode, o)
|
|
: new ReferenceError(o);
|
|
}
|
|
return i.res;
|
|
}
|
|
toString(e) {
|
|
return t.stringify(this, e);
|
|
}
|
|
};
|
|
p._defineProperty(be, 'default', !0);
|
|
function pt(t, e) {
|
|
let n = e instanceof P ? e.value : e;
|
|
for (let r of t)
|
|
if (
|
|
r instanceof T &&
|
|
(r.key === e || r.key === n || (r.key && r.key.value === n))
|
|
)
|
|
return r;
|
|
}
|
|
var mt = class extends j {
|
|
add(e, n) {
|
|
e ?
|
|
e instanceof T || (e = new T(e.key || e, e.value))
|
|
: (e = new T(e));
|
|
let r = pt(this.items, e.key),
|
|
s = this.schema && this.schema.sortMapEntries;
|
|
if (r)
|
|
if (n) r.value = e.value;
|
|
else throw new Error(`Key ${e.key} already set`);
|
|
else if (s) {
|
|
let i = this.items.findIndex((o) => s(e, o) < 0);
|
|
i === -1 ? this.items.push(e) : this.items.splice(i, 0, e);
|
|
} else this.items.push(e);
|
|
}
|
|
delete(e) {
|
|
let n = pt(this.items, e);
|
|
return n ?
|
|
this.items.splice(this.items.indexOf(n), 1).length > 0
|
|
: !1;
|
|
}
|
|
get(e, n) {
|
|
let r = pt(this.items, e),
|
|
s = r && r.value;
|
|
return !n && s instanceof P ? s.value : s;
|
|
}
|
|
has(e) {
|
|
return !!pt(this.items, e);
|
|
}
|
|
set(e, n) {
|
|
this.add(new T(e, n), !0);
|
|
}
|
|
toJSON(e, n, r) {
|
|
let s =
|
|
r ? new r()
|
|
: n && n.mapAsMap ? new Map()
|
|
: {};
|
|
n && n.onCreate && n.onCreate(s);
|
|
for (let i of this.items) i.addToJSMap(n, s);
|
|
return s;
|
|
}
|
|
toString(e, n, r) {
|
|
if (!e) return JSON.stringify(this);
|
|
for (let s of this.items)
|
|
if (!(s instanceof T))
|
|
throw new Error(
|
|
`Map items must all be pairs; found ${JSON.stringify(s)} instead`
|
|
);
|
|
return super.toString(
|
|
e,
|
|
{
|
|
blockItem: (s) => s.str,
|
|
flowChars: { start: '{', end: '}' },
|
|
isMap: !0,
|
|
itemIndent: e.indent || '',
|
|
},
|
|
n,
|
|
r
|
|
);
|
|
}
|
|
},
|
|
Fs = '<<',
|
|
Vt = class extends T {
|
|
constructor(e) {
|
|
if (e instanceof T) {
|
|
let n = e.value;
|
|
n instanceof pe ||
|
|
((n = new pe()),
|
|
n.items.push(e.value),
|
|
(n.range = e.value.range)),
|
|
super(e.key, n),
|
|
(this.range = e.range);
|
|
} else super(new P(Fs), new pe());
|
|
this.type = T.Type.MERGE_PAIR;
|
|
}
|
|
addToJSMap(e, n) {
|
|
for (let { source: r } of this.value.items) {
|
|
if (!(r instanceof mt))
|
|
throw new Error('Merge sources must be maps');
|
|
let s = r.toJSON(null, e, Map);
|
|
for (let [i, o] of s)
|
|
n instanceof Map ? n.has(i) || n.set(i, o)
|
|
: n instanceof Set ? n.add(i)
|
|
: Object.prototype.hasOwnProperty.call(n, i) ||
|
|
Object.defineProperty(n, i, {
|
|
value: o,
|
|
writable: !0,
|
|
enumerable: !0,
|
|
configurable: !0,
|
|
});
|
|
}
|
|
return n;
|
|
}
|
|
toString(e, n) {
|
|
let r = this.value;
|
|
if (r.items.length > 1) return super.toString(e, n);
|
|
this.value = r.items[0];
|
|
let s = super.toString(e, n);
|
|
return (this.value = r), s;
|
|
}
|
|
},
|
|
xo = { defaultType: p.Type.BLOCK_LITERAL, lineWidth: 76 },
|
|
Ro = { trueStr: 'true', falseStr: 'false' },
|
|
Do = { asBigInt: !1 },
|
|
Yo = { nullStr: 'null' },
|
|
Ne = {
|
|
defaultType: p.Type.PLAIN,
|
|
doubleQuoted: { jsonEncoding: !1, minMultiLineLength: 40 },
|
|
fold: { lineWidth: 80, minContentWidth: 20 },
|
|
};
|
|
function qn(t, e, n) {
|
|
for (let { format: r, test: s, resolve: i } of e)
|
|
if (s) {
|
|
let o = t.match(s);
|
|
if (o) {
|
|
let a = i.apply(null, o);
|
|
return a instanceof P || (a = new P(a)), r && (a.format = r), a;
|
|
}
|
|
}
|
|
return n && (t = n(t)), new P(t);
|
|
}
|
|
var qs = 'flow',
|
|
Fn = 'block',
|
|
Ut = 'quoted',
|
|
Ys = (t, e) => {
|
|
let n = t[e + 1];
|
|
for (; n === ' ' || n === ' '; ) {
|
|
do n = t[(e += 1)];
|
|
while (
|
|
n &&
|
|
n !==
|
|
`
|
|
`
|
|
);
|
|
n = t[e + 1];
|
|
}
|
|
return e;
|
|
};
|
|
function Wt(
|
|
t,
|
|
e,
|
|
n,
|
|
{
|
|
indentAtStart: r,
|
|
lineWidth: s = 80,
|
|
minContentWidth: i = 20,
|
|
onFold: o,
|
|
onOverflow: a,
|
|
}
|
|
) {
|
|
if (!s || s < 0) return t;
|
|
let c = Math.max(1 + i, 1 + s - e.length);
|
|
if (t.length <= c) return t;
|
|
let l = [],
|
|
f = {},
|
|
m = s - e.length;
|
|
typeof r == 'number' &&
|
|
(r > s - Math.max(2, i) ? l.push(0) : (m = s - r));
|
|
let d,
|
|
y,
|
|
h = !1,
|
|
g = -1,
|
|
w = -1,
|
|
C = -1;
|
|
n === Fn && ((g = Ys(t, g)), g !== -1 && (m = g + c));
|
|
for (let M; (M = t[(g += 1)]); ) {
|
|
if (n === Ut && M === '\\') {
|
|
switch (((w = g), t[g + 1])) {
|
|
case 'x':
|
|
g += 3;
|
|
break;
|
|
case 'u':
|
|
g += 5;
|
|
break;
|
|
case 'U':
|
|
g += 9;
|
|
break;
|
|
default:
|
|
g += 1;
|
|
}
|
|
C = g;
|
|
}
|
|
if (
|
|
M ===
|
|
`
|
|
`
|
|
)
|
|
n === Fn && (g = Ys(t, g)), (m = g + c), (d = void 0);
|
|
else {
|
|
if (
|
|
M === ' ' &&
|
|
y &&
|
|
y !== ' ' &&
|
|
y !==
|
|
`
|
|
` &&
|
|
y !== ' '
|
|
) {
|
|
let A = t[g + 1];
|
|
A &&
|
|
A !== ' ' &&
|
|
A !==
|
|
`
|
|
` &&
|
|
A !== ' ' &&
|
|
(d = g);
|
|
}
|
|
if (g >= m)
|
|
if (d) l.push(d), (m = d + c), (d = void 0);
|
|
else if (n === Ut) {
|
|
for (; y === ' ' || y === ' '; )
|
|
(y = M), (M = t[(g += 1)]), (h = !0);
|
|
let A = g > C + 1 ? g - 2 : w - 1;
|
|
if (f[A]) return t;
|
|
l.push(A), (f[A] = !0), (m = A + c), (d = void 0);
|
|
} else h = !0;
|
|
}
|
|
y = M;
|
|
}
|
|
if ((h && a && a(), l.length === 0)) return t;
|
|
o && o();
|
|
let L = t.slice(0, l[0]);
|
|
for (let M = 0; M < l.length; ++M) {
|
|
let A = l[M],
|
|
_ = l[M + 1] || t.length;
|
|
A === 0 ?
|
|
(L = `
|
|
${e}${t.slice(0, _)}`)
|
|
: (n === Ut && f[A] && (L += `${t[A]}\\`),
|
|
(L += `
|
|
${e}${t.slice(A + 1, _)}`));
|
|
}
|
|
return L;
|
|
}
|
|
var Un = ({ indentAtStart: t }) =>
|
|
t ? Object.assign({ indentAtStart: t }, Ne.fold) : Ne.fold,
|
|
jt = (t) => /^(%|---|\.\.\.)/m.test(t);
|
|
function $o(t, e, n) {
|
|
if (!e || e < 0) return !1;
|
|
let r = e - n,
|
|
s = t.length;
|
|
if (s <= r) return !1;
|
|
for (let i = 0, o = 0; i < s; ++i)
|
|
if (
|
|
t[i] ===
|
|
`
|
|
`
|
|
) {
|
|
if (i - o > r) return !0;
|
|
if (((o = i + 1), s - o <= r)) return !1;
|
|
}
|
|
return !0;
|
|
}
|
|
function we(t, e) {
|
|
let { implicitKey: n } = e,
|
|
{ jsonEncoding: r, minMultiLineLength: s } = Ne.doubleQuoted,
|
|
i = JSON.stringify(t);
|
|
if (r) return i;
|
|
let o = e.indent || (jt(t) ? ' ' : ''),
|
|
a = '',
|
|
c = 0;
|
|
for (let l = 0, f = i[l]; f; f = i[++l])
|
|
if (
|
|
(f === ' ' &&
|
|
i[l + 1] === '\\' &&
|
|
i[l + 2] === 'n' &&
|
|
((a += i.slice(c, l) + '\\ '), (l += 1), (c = l), (f = '\\')),
|
|
f === '\\')
|
|
)
|
|
switch (i[l + 1]) {
|
|
case 'u':
|
|
{
|
|
a += i.slice(c, l);
|
|
let m = i.substr(l + 2, 4);
|
|
switch (m) {
|
|
case '0000':
|
|
a += '\\0';
|
|
break;
|
|
case '0007':
|
|
a += '\\a';
|
|
break;
|
|
case '000b':
|
|
a += '\\v';
|
|
break;
|
|
case '001b':
|
|
a += '\\e';
|
|
break;
|
|
case '0085':
|
|
a += '\\N';
|
|
break;
|
|
case '00a0':
|
|
a += '\\_';
|
|
break;
|
|
case '2028':
|
|
a += '\\L';
|
|
break;
|
|
case '2029':
|
|
a += '\\P';
|
|
break;
|
|
default:
|
|
m.substr(0, 2) === '00' ?
|
|
(a += '\\x' + m.substr(2))
|
|
: (a += i.substr(l, 6));
|
|
}
|
|
(l += 5), (c = l + 1);
|
|
}
|
|
break;
|
|
case 'n':
|
|
if (n || i[l + 2] === '"' || i.length < s) l += 1;
|
|
else {
|
|
for (
|
|
a +=
|
|
i.slice(c, l) +
|
|
`
|
|
|
|
`;
|
|
i[l + 2] === '\\' && i[l + 3] === 'n' && i[l + 4] !== '"';
|
|
|
|
)
|
|
(a += `
|
|
`),
|
|
(l += 2);
|
|
(a += o),
|
|
i[l + 2] === ' ' && (a += '\\'),
|
|
(l += 1),
|
|
(c = l + 1);
|
|
}
|
|
break;
|
|
default:
|
|
l += 1;
|
|
}
|
|
return (a = c ? a + i.slice(c) : i), n ? a : Wt(a, o, Ut, Un(e));
|
|
}
|
|
function Us(t, e) {
|
|
if (e.implicitKey) {
|
|
if (/\n/.test(t)) return we(t, e);
|
|
} else if (/[ \t]\n|\n[ \t]/.test(t)) return we(t, e);
|
|
let n = e.indent || (jt(t) ? ' ' : ''),
|
|
r =
|
|
"'" +
|
|
t.replace(/'/g, "''").replace(
|
|
/\n+/g,
|
|
`$&
|
|
${n}`
|
|
) +
|
|
"'";
|
|
return e.implicitKey ? r : Wt(r, n, qs, Un(e));
|
|
}
|
|
function Kt({ comment: t, type: e, value: n }, r, s, i) {
|
|
if (/\n[\t ]+$/.test(n) || /^\s*$/.test(n)) return we(n, r);
|
|
let o = r.indent || (r.forceBlockIndent || jt(n) ? ' ' : ''),
|
|
a = o ? '2' : '1',
|
|
c =
|
|
e === p.Type.BLOCK_FOLDED ? !1
|
|
: e === p.Type.BLOCK_LITERAL ? !0
|
|
: !$o(n, Ne.fold.lineWidth, o.length),
|
|
l = c ? '|' : '>';
|
|
if (!n)
|
|
return (
|
|
l +
|
|
`
|
|
`
|
|
);
|
|
let f = '',
|
|
m = '';
|
|
if (
|
|
((n = n
|
|
.replace(/[\n\t ]*$/, (y) => {
|
|
let h = y.indexOf(`
|
|
`);
|
|
return (
|
|
h === -1 ?
|
|
(l += '-')
|
|
: (n === y || h !== y.length - 1) && ((l += '+'), i && i()),
|
|
(m = y.replace(/\n$/, '')),
|
|
''
|
|
);
|
|
})
|
|
.replace(/^[\n ]*/, (y) => {
|
|
y.indexOf(' ') !== -1 && (l += a);
|
|
let h = y.match(/ +$/);
|
|
return h ? ((f = y.slice(0, -h[0].length)), h[0]) : ((f = y), '');
|
|
})),
|
|
m && (m = m.replace(/\n+(?!\n|$)/g, `$&${o}`)),
|
|
f && (f = f.replace(/\n+/g, `$&${o}`)),
|
|
t && ((l += ' #' + t.replace(/ ?[\r\n]+/g, ' ')), s && s()),
|
|
!n)
|
|
)
|
|
return `${l}${a}
|
|
${o}${m}`;
|
|
if (c)
|
|
return (
|
|
(n = n.replace(/\n+/g, `$&${o}`)),
|
|
`${l}
|
|
${o}${f}${n}${m}`
|
|
);
|
|
n = n
|
|
.replace(
|
|
/\n+/g,
|
|
`
|
|
$&`
|
|
)
|
|
.replace(/(?:^|\n)([\t ].*)(?:([\n\t ]*)\n(?![\n\t ]))?/g, '$1$2')
|
|
.replace(/\n+/g, `$&${o}`);
|
|
let d = Wt(`${f}${n}${m}`, o, Fn, Ne.fold);
|
|
return `${l}
|
|
${o}${d}`;
|
|
}
|
|
function Bo(t, e, n, r) {
|
|
let { comment: s, type: i, value: o } = t,
|
|
{ actualString: a, implicitKey: c, indent: l, inFlow: f } = e;
|
|
if ((c && /[\n[\]{},]/.test(o)) || (f && /[[\]{},]/.test(o)))
|
|
return we(o, e);
|
|
if (
|
|
!o ||
|
|
/^[\n\t ,[\]{}#&*!|>'"%@`]|^[?-]$|^[?-][ \t]|[\n:][ \t]|[ \t]\n|[\n\t ]#|[\n\t :]$/.test(
|
|
o
|
|
)
|
|
)
|
|
return (
|
|
(
|
|
c ||
|
|
f ||
|
|
o.indexOf(`
|
|
`) === -1
|
|
) ?
|
|
o.indexOf('"') !== -1 && o.indexOf("'") === -1 ?
|
|
Us(o, e)
|
|
: we(o, e)
|
|
: Kt(t, e, n, r)
|
|
);
|
|
if (
|
|
!c &&
|
|
!f &&
|
|
i !== p.Type.PLAIN &&
|
|
o.indexOf(`
|
|
`) !== -1
|
|
)
|
|
return Kt(t, e, n, r);
|
|
if (l === '' && jt(o)) return (e.forceBlockIndent = !0), Kt(t, e, n, r);
|
|
let m = o.replace(
|
|
/\n+/g,
|
|
`$&
|
|
${l}`
|
|
);
|
|
if (a) {
|
|
let { tags: y } = e.doc.schema;
|
|
if (typeof qn(m, y, y.scalarFallback).value != 'string')
|
|
return we(o, e);
|
|
}
|
|
let d = c ? m : Wt(m, l, qs, Un(e));
|
|
return (
|
|
s &&
|
|
!f &&
|
|
(d.indexOf(`
|
|
`) !== -1 ||
|
|
s.indexOf(`
|
|
`) !== -1)
|
|
) ?
|
|
(n && n(), Po(d, l, s))
|
|
: d;
|
|
}
|
|
function Fo(t, e, n, r) {
|
|
let { defaultType: s } = Ne,
|
|
{ implicitKey: i, inFlow: o } = e,
|
|
{ type: a, value: c } = t;
|
|
typeof c != 'string' &&
|
|
((c = String(c)), (t = Object.assign({}, t, { value: c })));
|
|
let l = (m) => {
|
|
switch (m) {
|
|
case p.Type.BLOCK_FOLDED:
|
|
case p.Type.BLOCK_LITERAL:
|
|
return Kt(t, e, n, r);
|
|
case p.Type.QUOTE_DOUBLE:
|
|
return we(c, e);
|
|
case p.Type.QUOTE_SINGLE:
|
|
return Us(c, e);
|
|
case p.Type.PLAIN:
|
|
return Bo(t, e, n, r);
|
|
default:
|
|
return null;
|
|
}
|
|
};
|
|
((a !== p.Type.QUOTE_DOUBLE && /[\x00-\x08\x0b-\x1f\x7f-\x9f]/.test(c)) ||
|
|
((i || o) &&
|
|
(a === p.Type.BLOCK_FOLDED || a === p.Type.BLOCK_LITERAL))) &&
|
|
(a = p.Type.QUOTE_DOUBLE);
|
|
let f = l(a);
|
|
if (f === null && ((f = l(s)), f === null))
|
|
throw new Error(`Unsupported default string type ${s}`);
|
|
return f;
|
|
}
|
|
function qo({ format: t, minFractionDigits: e, tag: n, value: r }) {
|
|
if (typeof r == 'bigint') return String(r);
|
|
if (!isFinite(r))
|
|
return (
|
|
isNaN(r) ? '.nan'
|
|
: r < 0 ? '-.inf'
|
|
: '.inf'
|
|
);
|
|
let s = JSON.stringify(r);
|
|
if (!t && e && (!n || n === 'tag:yaml.org,2002:float') && /^\d/.test(s)) {
|
|
let i = s.indexOf('.');
|
|
i < 0 && ((i = s.length), (s += '.'));
|
|
let o = e - (s.length - i - 1);
|
|
for (; o-- > 0; ) s += '0';
|
|
}
|
|
return s;
|
|
}
|
|
function Ks(t, e) {
|
|
let n, r;
|
|
switch (e.type) {
|
|
case p.Type.FLOW_MAP:
|
|
(n = '}'), (r = 'flow map');
|
|
break;
|
|
case p.Type.FLOW_SEQ:
|
|
(n = ']'), (r = 'flow sequence');
|
|
break;
|
|
default:
|
|
t.push(new p.YAMLSemanticError(e, 'Not a flow collection!?'));
|
|
return;
|
|
}
|
|
let s;
|
|
for (let i = e.items.length - 1; i >= 0; --i) {
|
|
let o = e.items[i];
|
|
if (!o || o.type !== p.Type.COMMENT) {
|
|
s = o;
|
|
break;
|
|
}
|
|
}
|
|
if (s && s.char !== n) {
|
|
let i = `Expected ${r} to end with ${n}`,
|
|
o;
|
|
typeof s.offset == 'number' ?
|
|
((o = new p.YAMLSemanticError(e, i)), (o.offset = s.offset + 1))
|
|
: ((o = new p.YAMLSemanticError(s, i)),
|
|
s.range && s.range.end && (o.offset = s.range.end - s.range.start)),
|
|
t.push(o);
|
|
}
|
|
}
|
|
function Vs(t, e) {
|
|
let n = e.context.src[e.range.start - 1];
|
|
if (
|
|
n !==
|
|
`
|
|
` &&
|
|
n !== ' ' &&
|
|
n !== ' '
|
|
) {
|
|
let r =
|
|
'Comments must be separated from other tokens by white space characters';
|
|
t.push(new p.YAMLSemanticError(e, r));
|
|
}
|
|
}
|
|
function Ws(t, e) {
|
|
let n = String(e),
|
|
r = n.substr(0, 8) + '...' + n.substr(-8);
|
|
return new p.YAMLSemanticError(t, `The "${r}" key is too long`);
|
|
}
|
|
function js(t, e) {
|
|
for (let { afterKey: n, before: r, comment: s } of e) {
|
|
let i = t.items[r];
|
|
i ?
|
|
(n && i.value && (i = i.value),
|
|
s === void 0 ? (n || !i.commentBefore) && (i.spaceBefore = !0)
|
|
: i.commentBefore ?
|
|
(i.commentBefore +=
|
|
`
|
|
` + s)
|
|
: (i.commentBefore = s))
|
|
: s !== void 0 &&
|
|
(t.comment ?
|
|
(t.comment +=
|
|
`
|
|
` + s)
|
|
: (t.comment = s));
|
|
}
|
|
}
|
|
function Kn(t, e) {
|
|
let n = e.strValue;
|
|
return (
|
|
n ?
|
|
typeof n == 'string' ?
|
|
n
|
|
: (n.errors.forEach((r) => {
|
|
r.source || (r.source = e), t.errors.push(r);
|
|
}),
|
|
n.str)
|
|
: ''
|
|
);
|
|
}
|
|
function Uo(t, e) {
|
|
let { handle: n, suffix: r } = e.tag,
|
|
s = t.tagPrefixes.find((i) => i.handle === n);
|
|
if (!s) {
|
|
let i = t.getDefaults().tagPrefixes;
|
|
if ((i && (s = i.find((o) => o.handle === n)), !s))
|
|
throw new p.YAMLSemanticError(
|
|
e,
|
|
`The ${n} tag handle is non-default and was not declared.`
|
|
);
|
|
}
|
|
if (!r) throw new p.YAMLSemanticError(e, `The ${n} tag has no suffix.`);
|
|
if (n === '!' && (t.version || t.options.version) === '1.0') {
|
|
if (r[0] === '^')
|
|
return (
|
|
t.warnings.push(
|
|
new p.YAMLWarning(e, 'YAML 1.0 ^ tag expansion is not supported')
|
|
),
|
|
r
|
|
);
|
|
if (/[:/]/.test(r)) {
|
|
let i = r.match(/^([a-z0-9-]+)\/(.*)/i);
|
|
return i ? `tag:${i[1]}.yaml.org,2002:${i[2]}` : `tag:${r}`;
|
|
}
|
|
}
|
|
return s.prefix + decodeURIComponent(r);
|
|
}
|
|
function Ko(t, e) {
|
|
let { tag: n, type: r } = e,
|
|
s = !1;
|
|
if (n) {
|
|
let { handle: i, suffix: o, verbatim: a } = n;
|
|
if (a) {
|
|
if (a !== '!' && a !== '!!') return a;
|
|
let c = `Verbatim tags aren't resolved, so ${a} is invalid.`;
|
|
t.errors.push(new p.YAMLSemanticError(e, c));
|
|
} else if (i === '!' && !o) s = !0;
|
|
else
|
|
try {
|
|
return Uo(t, e);
|
|
} catch (c) {
|
|
t.errors.push(c);
|
|
}
|
|
}
|
|
switch (r) {
|
|
case p.Type.BLOCK_FOLDED:
|
|
case p.Type.BLOCK_LITERAL:
|
|
case p.Type.QUOTE_DOUBLE:
|
|
case p.Type.QUOTE_SINGLE:
|
|
return p.defaultTags.STR;
|
|
case p.Type.FLOW_MAP:
|
|
case p.Type.MAP:
|
|
return p.defaultTags.MAP;
|
|
case p.Type.FLOW_SEQ:
|
|
case p.Type.SEQ:
|
|
return p.defaultTags.SEQ;
|
|
case p.Type.PLAIN:
|
|
return s ? p.defaultTags.STR : null;
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
function $s(t, e, n) {
|
|
let { tags: r } = t.schema,
|
|
s = [];
|
|
for (let o of r)
|
|
if (o.tag === n)
|
|
if (o.test) s.push(o);
|
|
else {
|
|
let a = o.resolve(t, e);
|
|
return a instanceof j ? a : new P(a);
|
|
}
|
|
let i = Kn(t, e);
|
|
return typeof i == 'string' && s.length > 0 ?
|
|
qn(i, s, r.scalarFallback)
|
|
: null;
|
|
}
|
|
function Vo({ type: t }) {
|
|
switch (t) {
|
|
case p.Type.FLOW_MAP:
|
|
case p.Type.MAP:
|
|
return p.defaultTags.MAP;
|
|
case p.Type.FLOW_SEQ:
|
|
case p.Type.SEQ:
|
|
return p.defaultTags.SEQ;
|
|
default:
|
|
return p.defaultTags.STR;
|
|
}
|
|
}
|
|
function Wo(t, e, n) {
|
|
try {
|
|
let r = $s(t, e, n);
|
|
if (r) return n && e.tag && (r.tag = n), r;
|
|
} catch (r) {
|
|
return r.source || (r.source = e), t.errors.push(r), null;
|
|
}
|
|
try {
|
|
let r = Vo(e);
|
|
if (!r) throw new Error(`The tag ${n} is unavailable`);
|
|
let s = `The tag ${n} is unavailable, falling back to ${r}`;
|
|
t.warnings.push(new p.YAMLWarning(e, s));
|
|
let i = $s(t, e, r);
|
|
return (i.tag = n), i;
|
|
} catch (r) {
|
|
let s = new p.YAMLReferenceError(e, r.message);
|
|
return (s.stack = r.stack), t.errors.push(s), null;
|
|
}
|
|
}
|
|
var jo = (t) => {
|
|
if (!t) return !1;
|
|
let { type: e } = t;
|
|
return (
|
|
e === p.Type.MAP_KEY || e === p.Type.MAP_VALUE || e === p.Type.SEQ_ITEM
|
|
);
|
|
};
|
|
function Qo(t, e) {
|
|
let n = { before: [], after: [] },
|
|
r = !1,
|
|
s = !1,
|
|
i =
|
|
jo(e.context.parent) ?
|
|
e.context.parent.props.concat(e.props)
|
|
: e.props;
|
|
for (let { start: o, end: a } of i)
|
|
switch (e.context.src[o]) {
|
|
case p.Char.COMMENT: {
|
|
if (!e.commentHasRequiredWhitespace(o)) {
|
|
let m =
|
|
'Comments must be separated from other tokens by white space characters';
|
|
t.push(new p.YAMLSemanticError(e, m));
|
|
}
|
|
let { header: c, valueRange: l } = e;
|
|
(l && (o > l.start || (c && o > c.start)) ?
|
|
n.after
|
|
: n.before
|
|
).push(e.context.src.slice(o + 1, a));
|
|
break;
|
|
}
|
|
case p.Char.ANCHOR:
|
|
if (r) {
|
|
let c = 'A node can have at most one anchor';
|
|
t.push(new p.YAMLSemanticError(e, c));
|
|
}
|
|
r = !0;
|
|
break;
|
|
case p.Char.TAG:
|
|
if (s) {
|
|
let c = 'A node can have at most one tag';
|
|
t.push(new p.YAMLSemanticError(e, c));
|
|
}
|
|
s = !0;
|
|
break;
|
|
}
|
|
return { comments: n, hasAnchor: r, hasTag: s };
|
|
}
|
|
function Jo(t, e) {
|
|
let { anchors: n, errors: r, schema: s } = t;
|
|
if (e.type === p.Type.ALIAS) {
|
|
let o = e.rawValue,
|
|
a = n.getNode(o);
|
|
if (!a) {
|
|
let l = `Aliased anchor not found: ${o}`;
|
|
return r.push(new p.YAMLReferenceError(e, l)), null;
|
|
}
|
|
let c = new be(a);
|
|
return n._cstAliases.push(c), c;
|
|
}
|
|
let i = Ko(t, e);
|
|
if (i) return Wo(t, e, i);
|
|
if (e.type !== p.Type.PLAIN) {
|
|
let o = `Failed to resolve ${e.type} node here`;
|
|
return r.push(new p.YAMLSyntaxError(e, o)), null;
|
|
}
|
|
try {
|
|
let o = Kn(t, e);
|
|
return qn(o, s.tags, s.tags.scalarFallback);
|
|
} catch (o) {
|
|
return o.source || (o.source = e), r.push(o), null;
|
|
}
|
|
}
|
|
function me(t, e) {
|
|
if (!e) return null;
|
|
e.error && t.errors.push(e.error);
|
|
let { comments: n, hasAnchor: r, hasTag: s } = Qo(t.errors, e);
|
|
if (r) {
|
|
let { anchors: o } = t,
|
|
a = e.anchor,
|
|
c = o.getNode(a);
|
|
c && (o.map[o.newName(a)] = c), (o.map[a] = e);
|
|
}
|
|
if (e.type === p.Type.ALIAS && (r || s)) {
|
|
let o = 'An alias node must not specify any properties';
|
|
t.errors.push(new p.YAMLSemanticError(e, o));
|
|
}
|
|
let i = Jo(t, e);
|
|
if (i) {
|
|
(i.range = [e.range.start, e.range.end]),
|
|
t.options.keepCstNodes && (i.cstNode = e),
|
|
t.options.keepNodeTypes && (i.type = e.type);
|
|
let o = n.before.join(`
|
|
`);
|
|
o &&
|
|
(i.commentBefore =
|
|
i.commentBefore ?
|
|
`${i.commentBefore}
|
|
${o}`
|
|
: o);
|
|
let a = n.after.join(`
|
|
`);
|
|
a &&
|
|
(i.comment =
|
|
i.comment ?
|
|
`${i.comment}
|
|
${a}`
|
|
: a);
|
|
}
|
|
return (e.resolved = i);
|
|
}
|
|
function Go(t, e) {
|
|
if (e.type !== p.Type.MAP && e.type !== p.Type.FLOW_MAP) {
|
|
let o = `A ${e.type} node cannot be resolved as a mapping`;
|
|
return t.errors.push(new p.YAMLSyntaxError(e, o)), null;
|
|
}
|
|
let { comments: n, items: r } =
|
|
e.type === p.Type.FLOW_MAP ? Zo(t, e) : zo(t, e),
|
|
s = new mt();
|
|
(s.items = r), js(s, n);
|
|
let i = !1;
|
|
for (let o = 0; o < r.length; ++o) {
|
|
let { key: a } = r[o];
|
|
if (
|
|
(a instanceof j && (i = !0), t.schema.merge && a && a.value === Fs)
|
|
) {
|
|
r[o] = new Vt(r[o]);
|
|
let c = r[o].value.items,
|
|
l = null;
|
|
c.some((f) => {
|
|
if (f instanceof be) {
|
|
let { type: m } = f.source;
|
|
return m === p.Type.MAP || m === p.Type.FLOW_MAP ?
|
|
!1
|
|
: (l = 'Merge nodes aliases can only point to maps');
|
|
}
|
|
return (l = 'Merge nodes can only have Alias nodes as values');
|
|
}),
|
|
l && t.errors.push(new p.YAMLSemanticError(e, l));
|
|
} else
|
|
for (let c = o + 1; c < r.length; ++c) {
|
|
let { key: l } = r[c];
|
|
if (
|
|
a === l ||
|
|
(a &&
|
|
l &&
|
|
Object.prototype.hasOwnProperty.call(a, 'value') &&
|
|
a.value === l.value)
|
|
) {
|
|
let f = `Map keys must be unique; "${a}" is repeated`;
|
|
t.errors.push(new p.YAMLSemanticError(e, f));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (i && !t.options.mapAsMap) {
|
|
let o =
|
|
'Keys with collection values will be stringified as YAML due to JS Object restrictions. Use mapAsMap: true to avoid this.';
|
|
t.warnings.push(new p.YAMLWarning(e, o));
|
|
}
|
|
return (e.resolved = s), s;
|
|
}
|
|
var Ho = ({ context: { lineStart: t, node: e, src: n }, props: r }) => {
|
|
if (r.length === 0) return !1;
|
|
let { start: s } = r[0];
|
|
if ((e && s > e.valueRange.start) || n[s] !== p.Char.COMMENT) return !1;
|
|
for (let i = t; i < s; ++i)
|
|
if (
|
|
n[i] ===
|
|
`
|
|
`
|
|
)
|
|
return !1;
|
|
return !0;
|
|
};
|
|
function Xo(t, e) {
|
|
if (!Ho(t)) return;
|
|
let n = t.getPropValue(0, p.Char.COMMENT, !0),
|
|
r = !1,
|
|
s = e.value.commentBefore;
|
|
if (s && s.startsWith(n))
|
|
(e.value.commentBefore = s.substr(n.length + 1)), (r = !0);
|
|
else {
|
|
let i = e.value.comment;
|
|
!t.node &&
|
|
i &&
|
|
i.startsWith(n) &&
|
|
((e.value.comment = i.substr(n.length + 1)), (r = !0));
|
|
}
|
|
r && (e.comment = n);
|
|
}
|
|
function zo(t, e) {
|
|
let n = [],
|
|
r = [],
|
|
s,
|
|
i = null;
|
|
for (let o = 0; o < e.items.length; ++o) {
|
|
let a = e.items[o];
|
|
switch (a.type) {
|
|
case p.Type.BLANK_LINE:
|
|
n.push({ afterKey: !!s, before: r.length });
|
|
break;
|
|
case p.Type.COMMENT:
|
|
n.push({ afterKey: !!s, before: r.length, comment: a.comment });
|
|
break;
|
|
case p.Type.MAP_KEY:
|
|
s !== void 0 && r.push(new T(s)),
|
|
a.error && t.errors.push(a.error),
|
|
(s = me(t, a.node)),
|
|
(i = null);
|
|
break;
|
|
case p.Type.MAP_VALUE:
|
|
{
|
|
if (
|
|
(s === void 0 && (s = null),
|
|
a.error && t.errors.push(a.error),
|
|
!a.context.atLineStart &&
|
|
a.node &&
|
|
a.node.type === p.Type.MAP &&
|
|
!a.node.context.atLineStart)
|
|
) {
|
|
let f = 'Nested mappings are not allowed in compact mappings';
|
|
t.errors.push(new p.YAMLSemanticError(a.node, f));
|
|
}
|
|
let c = a.node;
|
|
if (!c && a.props.length > 0) {
|
|
(c = new p.PlainValue(p.Type.PLAIN, [])),
|
|
(c.context = { parent: a, src: a.context.src });
|
|
let f = a.range.start + 1;
|
|
if (
|
|
((c.range = { start: f, end: f }),
|
|
(c.valueRange = { start: f, end: f }),
|
|
typeof a.range.origStart == 'number')
|
|
) {
|
|
let m = a.range.origStart + 1;
|
|
(c.range.origStart = c.range.origEnd = m),
|
|
(c.valueRange.origStart = c.valueRange.origEnd = m);
|
|
}
|
|
}
|
|
let l = new T(s, me(t, c));
|
|
Xo(a, l),
|
|
r.push(l),
|
|
s &&
|
|
typeof i == 'number' &&
|
|
a.range.start > i + 1024 &&
|
|
t.errors.push(Ws(e, s)),
|
|
(s = void 0),
|
|
(i = null);
|
|
}
|
|
break;
|
|
default:
|
|
s !== void 0 && r.push(new T(s)),
|
|
(s = me(t, a)),
|
|
(i = a.range.start),
|
|
a.error && t.errors.push(a.error);
|
|
e: for (let c = o + 1; ; ++c) {
|
|
let l = e.items[c];
|
|
switch (l && l.type) {
|
|
case p.Type.BLANK_LINE:
|
|
case p.Type.COMMENT:
|
|
continue e;
|
|
case p.Type.MAP_VALUE:
|
|
break e;
|
|
default: {
|
|
let f = 'Implicit map keys need to be followed by map values';
|
|
t.errors.push(new p.YAMLSemanticError(a, f));
|
|
break e;
|
|
}
|
|
}
|
|
}
|
|
if (a.valueRangeContainsNewline) {
|
|
let c = 'Implicit map keys need to be on a single line';
|
|
t.errors.push(new p.YAMLSemanticError(a, c));
|
|
}
|
|
}
|
|
}
|
|
return s !== void 0 && r.push(new T(s)), { comments: n, items: r };
|
|
}
|
|
function Zo(t, e) {
|
|
let n = [],
|
|
r = [],
|
|
s,
|
|
i = !1,
|
|
o = '{';
|
|
for (let a = 0; a < e.items.length; ++a) {
|
|
let c = e.items[a];
|
|
if (typeof c.char == 'string') {
|
|
let { char: l, offset: f } = c;
|
|
if (l === '?' && s === void 0 && !i) {
|
|
(i = !0), (o = ':');
|
|
continue;
|
|
}
|
|
if (l === ':') {
|
|
if ((s === void 0 && (s = null), o === ':')) {
|
|
o = ',';
|
|
continue;
|
|
}
|
|
} else if (
|
|
(i && (s === void 0 && l !== ',' && (s = null), (i = !1)),
|
|
s !== void 0 && (r.push(new T(s)), (s = void 0), l === ','))
|
|
) {
|
|
o = ':';
|
|
continue;
|
|
}
|
|
if (l === '}') {
|
|
if (a === e.items.length - 1) continue;
|
|
} else if (l === o) {
|
|
o = ':';
|
|
continue;
|
|
}
|
|
let m = `Flow map contains an unexpected ${l}`,
|
|
d = new p.YAMLSyntaxError(e, m);
|
|
(d.offset = f), t.errors.push(d);
|
|
} else
|
|
c.type === p.Type.BLANK_LINE ?
|
|
n.push({ afterKey: !!s, before: r.length })
|
|
: c.type === p.Type.COMMENT ?
|
|
(Vs(t.errors, c),
|
|
n.push({ afterKey: !!s, before: r.length, comment: c.comment }))
|
|
: s === void 0 ?
|
|
(o === ',' &&
|
|
t.errors.push(
|
|
new p.YAMLSemanticError(c, 'Separator , missing in flow map')
|
|
),
|
|
(s = me(t, c)))
|
|
: (o !== ',' &&
|
|
t.errors.push(
|
|
new p.YAMLSemanticError(
|
|
c,
|
|
'Indicator : missing in flow map entry'
|
|
)
|
|
),
|
|
r.push(new T(s, me(t, c))),
|
|
(s = void 0),
|
|
(i = !1));
|
|
}
|
|
return (
|
|
Ks(t.errors, e),
|
|
s !== void 0 && r.push(new T(s)),
|
|
{ comments: n, items: r }
|
|
);
|
|
}
|
|
function ea(t, e) {
|
|
if (e.type !== p.Type.SEQ && e.type !== p.Type.FLOW_SEQ) {
|
|
let i = `A ${e.type} node cannot be resolved as a sequence`;
|
|
return t.errors.push(new p.YAMLSyntaxError(e, i)), null;
|
|
}
|
|
let { comments: n, items: r } =
|
|
e.type === p.Type.FLOW_SEQ ? na(t, e) : ta(t, e),
|
|
s = new pe();
|
|
if (
|
|
((s.items = r),
|
|
js(s, n),
|
|
!t.options.mapAsMap &&
|
|
r.some((i) => i instanceof T && i.key instanceof j))
|
|
) {
|
|
let i =
|
|
'Keys with collection values will be stringified as YAML due to JS Object restrictions. Use mapAsMap: true to avoid this.';
|
|
t.warnings.push(new p.YAMLWarning(e, i));
|
|
}
|
|
return (e.resolved = s), s;
|
|
}
|
|
function ta(t, e) {
|
|
let n = [],
|
|
r = [];
|
|
for (let s = 0; s < e.items.length; ++s) {
|
|
let i = e.items[s];
|
|
switch (i.type) {
|
|
case p.Type.BLANK_LINE:
|
|
n.push({ before: r.length });
|
|
break;
|
|
case p.Type.COMMENT:
|
|
n.push({ comment: i.comment, before: r.length });
|
|
break;
|
|
case p.Type.SEQ_ITEM:
|
|
if (
|
|
(i.error && t.errors.push(i.error),
|
|
r.push(me(t, i.node)),
|
|
i.hasProps)
|
|
) {
|
|
let o =
|
|
'Sequence items cannot have tags or anchors before the - indicator';
|
|
t.errors.push(new p.YAMLSemanticError(i, o));
|
|
}
|
|
break;
|
|
default:
|
|
i.error && t.errors.push(i.error),
|
|
t.errors.push(
|
|
new p.YAMLSyntaxError(
|
|
i,
|
|
`Unexpected ${i.type} node in sequence`
|
|
)
|
|
);
|
|
}
|
|
}
|
|
return { comments: n, items: r };
|
|
}
|
|
function na(t, e) {
|
|
let n = [],
|
|
r = [],
|
|
s = !1,
|
|
i,
|
|
o = null,
|
|
a = '[',
|
|
c = null;
|
|
for (let l = 0; l < e.items.length; ++l) {
|
|
let f = e.items[l];
|
|
if (typeof f.char == 'string') {
|
|
let { char: m, offset: d } = f;
|
|
if (
|
|
(m !== ':' &&
|
|
(s || i !== void 0) &&
|
|
(s && i === void 0 && (i = a ? r.pop() : null),
|
|
r.push(new T(i)),
|
|
(s = !1),
|
|
(i = void 0),
|
|
(o = null)),
|
|
m === a)
|
|
)
|
|
a = null;
|
|
else if (!a && m === '?') s = !0;
|
|
else if (a !== '[' && m === ':' && i === void 0) {
|
|
if (a === ',') {
|
|
if (((i = r.pop()), i instanceof T)) {
|
|
let y = 'Chaining flow sequence pairs is invalid',
|
|
h = new p.YAMLSemanticError(e, y);
|
|
(h.offset = d), t.errors.push(h);
|
|
}
|
|
if (!s && typeof o == 'number') {
|
|
let y = f.range ? f.range.start : f.offset;
|
|
y > o + 1024 && t.errors.push(Ws(e, i));
|
|
let { src: h } = c.context;
|
|
for (let g = o; g < y; ++g)
|
|
if (
|
|
h[g] ===
|
|
`
|
|
`
|
|
) {
|
|
let w =
|
|
'Implicit keys of flow sequence pairs need to be on a single line';
|
|
t.errors.push(new p.YAMLSemanticError(c, w));
|
|
break;
|
|
}
|
|
}
|
|
} else i = null;
|
|
(o = null), (s = !1), (a = null);
|
|
} else if (a === '[' || m !== ']' || l < e.items.length - 1) {
|
|
let y = `Flow sequence contains an unexpected ${m}`,
|
|
h = new p.YAMLSyntaxError(e, y);
|
|
(h.offset = d), t.errors.push(h);
|
|
}
|
|
} else if (f.type === p.Type.BLANK_LINE) n.push({ before: r.length });
|
|
else if (f.type === p.Type.COMMENT)
|
|
Vs(t.errors, f), n.push({ comment: f.comment, before: r.length });
|
|
else {
|
|
if (a) {
|
|
let d = `Expected a ${a} in flow sequence`;
|
|
t.errors.push(new p.YAMLSemanticError(f, d));
|
|
}
|
|
let m = me(t, f);
|
|
i === void 0 ?
|
|
(r.push(m), (c = f))
|
|
: (r.push(new T(i, m)), (i = void 0)),
|
|
(o = f.range.start),
|
|
(a = ',');
|
|
}
|
|
}
|
|
return (
|
|
Ks(t.errors, e),
|
|
i !== void 0 && r.push(new T(i)),
|
|
{ comments: n, items: r }
|
|
);
|
|
}
|
|
k.Alias = be;
|
|
k.Collection = j;
|
|
k.Merge = Vt;
|
|
k.Node = W;
|
|
k.Pair = T;
|
|
k.Scalar = P;
|
|
k.YAMLMap = mt;
|
|
k.YAMLSeq = pe;
|
|
k.addComment = Fe;
|
|
k.binaryOptions = xo;
|
|
k.boolOptions = Ro;
|
|
k.findPair = pt;
|
|
k.intOptions = Do;
|
|
k.isEmptyPath = Bs;
|
|
k.nullOptions = Yo;
|
|
k.resolveMap = Go;
|
|
k.resolveNode = me;
|
|
k.resolveSeq = ea;
|
|
k.resolveString = Kn;
|
|
k.strOptions = Ne;
|
|
k.stringifyNumber = qo;
|
|
k.stringifyString = Fo;
|
|
k.toJSON = ue;
|
|
});
|
|
var Qn = te((z) => {
|
|
'use strict';
|
|
var Q = le(),
|
|
O = qe(),
|
|
ra = {
|
|
identify: (t) => t instanceof Uint8Array,
|
|
default: !1,
|
|
tag: 'tag:yaml.org,2002:binary',
|
|
resolve: (t, e) => {
|
|
let n = O.resolveString(t, e);
|
|
if (typeof Buffer == 'function') return Buffer.from(n, 'base64');
|
|
if (typeof atob == 'function') {
|
|
let r = atob(n.replace(/[\n\r]/g, '')),
|
|
s = new Uint8Array(r.length);
|
|
for (let i = 0; i < r.length; ++i) s[i] = r.charCodeAt(i);
|
|
return s;
|
|
} else {
|
|
let r =
|
|
'This environment does not support reading binary tags; either Buffer or atob is required';
|
|
return t.errors.push(new Q.YAMLReferenceError(e, r)), null;
|
|
}
|
|
},
|
|
options: O.binaryOptions,
|
|
stringify: ({ comment: t, type: e, value: n }, r, s, i) => {
|
|
let o;
|
|
if (typeof Buffer == 'function')
|
|
o =
|
|
n instanceof Buffer ?
|
|
n.toString('base64')
|
|
: Buffer.from(n.buffer).toString('base64');
|
|
else if (typeof btoa == 'function') {
|
|
let a = '';
|
|
for (let c = 0; c < n.length; ++c) a += String.fromCharCode(n[c]);
|
|
o = btoa(a);
|
|
} else
|
|
throw new Error(
|
|
'This environment does not support writing binary tags; either Buffer or btoa is required'
|
|
);
|
|
if (
|
|
(e || (e = O.binaryOptions.defaultType), e === Q.Type.QUOTE_DOUBLE)
|
|
)
|
|
n = o;
|
|
else {
|
|
let { lineWidth: a } = O.binaryOptions,
|
|
c = Math.ceil(o.length / a),
|
|
l = new Array(c);
|
|
for (let f = 0, m = 0; f < c; ++f, m += a) l[f] = o.substr(m, a);
|
|
n = l.join(
|
|
e === Q.Type.BLOCK_LITERAL ?
|
|
`
|
|
`
|
|
: ' '
|
|
);
|
|
}
|
|
return O.stringifyString({ comment: t, type: e, value: n }, r, s, i);
|
|
},
|
|
};
|
|
function Js(t, e) {
|
|
let n = O.resolveSeq(t, e);
|
|
for (let r = 0; r < n.items.length; ++r) {
|
|
let s = n.items[r];
|
|
if (!(s instanceof O.Pair)) {
|
|
if (s instanceof O.YAMLMap) {
|
|
if (s.items.length > 1) {
|
|
let o = 'Each pair must have its own sequence indicator';
|
|
throw new Q.YAMLSemanticError(e, o);
|
|
}
|
|
let i = s.items[0] || new O.Pair();
|
|
s.commentBefore &&
|
|
(i.commentBefore =
|
|
i.commentBefore ?
|
|
`${s.commentBefore}
|
|
${i.commentBefore}`
|
|
: s.commentBefore),
|
|
s.comment &&
|
|
(i.comment =
|
|
i.comment ?
|
|
`${s.comment}
|
|
${i.comment}`
|
|
: s.comment),
|
|
(s = i);
|
|
}
|
|
n.items[r] = s instanceof O.Pair ? s : new O.Pair(s);
|
|
}
|
|
}
|
|
return n;
|
|
}
|
|
function Gs(t, e, n) {
|
|
let r = new O.YAMLSeq(t);
|
|
r.tag = 'tag:yaml.org,2002:pairs';
|
|
for (let s of e) {
|
|
let i, o;
|
|
if (Array.isArray(s))
|
|
if (s.length === 2) (i = s[0]), (o = s[1]);
|
|
else throw new TypeError(`Expected [key, value] tuple: ${s}`);
|
|
else if (s && s instanceof Object) {
|
|
let c = Object.keys(s);
|
|
if (c.length === 1) (i = c[0]), (o = s[i]);
|
|
else throw new TypeError(`Expected { key: value } tuple: ${s}`);
|
|
} else i = s;
|
|
let a = t.createPair(i, o, n);
|
|
r.items.push(a);
|
|
}
|
|
return r;
|
|
}
|
|
var sa = {
|
|
default: !1,
|
|
tag: 'tag:yaml.org,2002:pairs',
|
|
resolve: Js,
|
|
createNode: Gs,
|
|
},
|
|
Ue = class t extends O.YAMLSeq {
|
|
constructor() {
|
|
super(),
|
|
Q._defineProperty(this, 'add', O.YAMLMap.prototype.add.bind(this)),
|
|
Q._defineProperty(
|
|
this,
|
|
'delete',
|
|
O.YAMLMap.prototype.delete.bind(this)
|
|
),
|
|
Q._defineProperty(this, 'get', O.YAMLMap.prototype.get.bind(this)),
|
|
Q._defineProperty(this, 'has', O.YAMLMap.prototype.has.bind(this)),
|
|
Q._defineProperty(this, 'set', O.YAMLMap.prototype.set.bind(this)),
|
|
(this.tag = t.tag);
|
|
}
|
|
toJSON(e, n) {
|
|
let r = new Map();
|
|
n && n.onCreate && n.onCreate(r);
|
|
for (let s of this.items) {
|
|
let i, o;
|
|
if (
|
|
(s instanceof O.Pair ?
|
|
((i = O.toJSON(s.key, '', n)), (o = O.toJSON(s.value, i, n)))
|
|
: (i = O.toJSON(s, '', n)),
|
|
r.has(i))
|
|
)
|
|
throw new Error('Ordered maps must not include duplicate keys');
|
|
r.set(i, o);
|
|
}
|
|
return r;
|
|
}
|
|
};
|
|
Q._defineProperty(Ue, 'tag', 'tag:yaml.org,2002:omap');
|
|
function ia(t, e) {
|
|
let n = Js(t, e),
|
|
r = [];
|
|
for (let { key: s } of n.items)
|
|
if (s instanceof O.Scalar)
|
|
if (r.includes(s.value)) {
|
|
let i = 'Ordered maps must not include duplicate keys';
|
|
throw new Q.YAMLSemanticError(e, i);
|
|
} else r.push(s.value);
|
|
return Object.assign(new Ue(), n);
|
|
}
|
|
function oa(t, e, n) {
|
|
let r = Gs(t, e, n),
|
|
s = new Ue();
|
|
return (s.items = r.items), s;
|
|
}
|
|
var aa = {
|
|
identify: (t) => t instanceof Map,
|
|
nodeClass: Ue,
|
|
default: !1,
|
|
tag: 'tag:yaml.org,2002:omap',
|
|
resolve: ia,
|
|
createNode: oa,
|
|
},
|
|
Ke = class t extends O.YAMLMap {
|
|
constructor() {
|
|
super(), (this.tag = t.tag);
|
|
}
|
|
add(e) {
|
|
let n = e instanceof O.Pair ? e : new O.Pair(e);
|
|
O.findPair(this.items, n.key) || this.items.push(n);
|
|
}
|
|
get(e, n) {
|
|
let r = O.findPair(this.items, e);
|
|
return (
|
|
!n && r instanceof O.Pair ?
|
|
r.key instanceof O.Scalar ?
|
|
r.key.value
|
|
: r.key
|
|
: r
|
|
);
|
|
}
|
|
set(e, n) {
|
|
if (typeof n != 'boolean')
|
|
throw new Error(
|
|
`Expected boolean value for set(key, value) in a YAML set, not ${typeof n}`
|
|
);
|
|
let r = O.findPair(this.items, e);
|
|
r && !n ?
|
|
this.items.splice(this.items.indexOf(r), 1)
|
|
: !r && n && this.items.push(new O.Pair(e));
|
|
}
|
|
toJSON(e, n) {
|
|
return super.toJSON(e, n, Set);
|
|
}
|
|
toString(e, n, r) {
|
|
if (!e) return JSON.stringify(this);
|
|
if (this.hasAllNullValues()) return super.toString(e, n, r);
|
|
throw new Error('Set items must all have null values');
|
|
}
|
|
};
|
|
Q._defineProperty(Ke, 'tag', 'tag:yaml.org,2002:set');
|
|
function ca(t, e) {
|
|
let n = O.resolveMap(t, e);
|
|
if (!n.hasAllNullValues())
|
|
throw new Q.YAMLSemanticError(e, 'Set items must all have null values');
|
|
return Object.assign(new Ke(), n);
|
|
}
|
|
function la(t, e, n) {
|
|
let r = new Ke();
|
|
for (let s of e) r.items.push(t.createPair(s, null, n));
|
|
return r;
|
|
}
|
|
var fa = {
|
|
identify: (t) => t instanceof Set,
|
|
nodeClass: Ke,
|
|
default: !1,
|
|
tag: 'tag:yaml.org,2002:set',
|
|
resolve: ca,
|
|
createNode: la,
|
|
},
|
|
Vn = (t, e) => {
|
|
let n = e.split(':').reduce((r, s) => r * 60 + Number(s), 0);
|
|
return t === '-' ? -n : n;
|
|
},
|
|
Hs = ({ value: t }) => {
|
|
if (isNaN(t) || !isFinite(t)) return O.stringifyNumber(t);
|
|
let e = '';
|
|
t < 0 && ((e = '-'), (t = Math.abs(t)));
|
|
let n = [t % 60];
|
|
return (
|
|
t < 60 ?
|
|
n.unshift(0)
|
|
: ((t = Math.round((t - n[0]) / 60)),
|
|
n.unshift(t % 60),
|
|
t >= 60 && ((t = Math.round((t - n[0]) / 60)), n.unshift(t))),
|
|
e +
|
|
n
|
|
.map((r) => (r < 10 ? '0' + String(r) : String(r)))
|
|
.join(':')
|
|
.replace(/000000\d*$/, '')
|
|
);
|
|
},
|
|
ua = {
|
|
identify: (t) => typeof t == 'number',
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:int',
|
|
format: 'TIME',
|
|
test: /^([-+]?)([0-9][0-9_]*(?::[0-5]?[0-9])+)$/,
|
|
resolve: (t, e, n) => Vn(e, n.replace(/_/g, '')),
|
|
stringify: Hs,
|
|
},
|
|
pa = {
|
|
identify: (t) => typeof t == 'number',
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:float',
|
|
format: 'TIME',
|
|
test: /^([-+]?)([0-9][0-9_]*(?::[0-5]?[0-9])+\.[0-9_]*)$/,
|
|
resolve: (t, e, n) => Vn(e, n.replace(/_/g, '')),
|
|
stringify: Hs,
|
|
},
|
|
ma = {
|
|
identify: (t) => t instanceof Date,
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:timestamp',
|
|
test: RegExp(
|
|
'^(?:([0-9]{4})-([0-9]{1,2})-([0-9]{1,2})(?:(?:t|T|[ \\t]+)([0-9]{1,2}):([0-9]{1,2}):([0-9]{1,2}(\\.[0-9]+)?)(?:[ \\t]*(Z|[-+][012]?[0-9](?::[0-9]{2})?))?)?)$'
|
|
),
|
|
resolve: (t, e, n, r, s, i, o, a, c) => {
|
|
a && (a = (a + '00').substr(1, 3));
|
|
let l = Date.UTC(e, n - 1, r, s || 0, i || 0, o || 0, a || 0);
|
|
if (c && c !== 'Z') {
|
|
let f = Vn(c[0], c.slice(1));
|
|
Math.abs(f) < 30 && (f *= 60), (l -= 6e4 * f);
|
|
}
|
|
return new Date(l);
|
|
},
|
|
stringify: ({ value: t }) =>
|
|
t.toISOString().replace(/((T00:00)?:00)?\.000Z$/, ''),
|
|
};
|
|
function Wn(t) {
|
|
let e = {};
|
|
return (
|
|
t ?
|
|
typeof YAML_SILENCE_DEPRECATION_WARNINGS < 'u' ?
|
|
!YAML_SILENCE_DEPRECATION_WARNINGS
|
|
: !e.YAML_SILENCE_DEPRECATION_WARNINGS
|
|
: typeof YAML_SILENCE_WARNINGS < 'u' ? !YAML_SILENCE_WARNINGS
|
|
: !e.YAML_SILENCE_WARNINGS
|
|
);
|
|
}
|
|
function jn(t, e) {
|
|
Wn(!1) && console.warn(e ? `${e}: ${t}` : t);
|
|
}
|
|
function ha(t) {
|
|
if (Wn(!0)) {
|
|
let e = t
|
|
.replace(/.*yaml[/\\]/i, '')
|
|
.replace(/\.js$/, '')
|
|
.replace(/\\/g, '/');
|
|
jn(
|
|
`The endpoint 'yaml/${e}' will be removed in a future release.`,
|
|
'DeprecationWarning'
|
|
);
|
|
}
|
|
}
|
|
var Qs = {};
|
|
function ga(t, e) {
|
|
if (!Qs[t] && Wn(!0)) {
|
|
Qs[t] = !0;
|
|
let n = `The option '${t}' will be removed in a future release`;
|
|
(n += e ? `, use '${e}' instead.` : '.'), jn(n, 'DeprecationWarning');
|
|
}
|
|
}
|
|
z.binary = ra;
|
|
z.floatTime = pa;
|
|
z.intTime = ua;
|
|
z.omap = aa;
|
|
z.pairs = sa;
|
|
z.set = fa;
|
|
z.timestamp = ma;
|
|
z.warn = jn;
|
|
z.warnFileDeprecation = ha;
|
|
z.warnOptionDeprecation = ga;
|
|
});
|
|
var Xn = te((li) => {
|
|
'use strict';
|
|
var Gt = le(),
|
|
E = qe(),
|
|
D = Qn();
|
|
function da(t, e, n) {
|
|
let r = new E.YAMLMap(t);
|
|
if (e instanceof Map)
|
|
for (let [s, i] of e) r.items.push(t.createPair(s, i, n));
|
|
else if (e && typeof e == 'object')
|
|
for (let s of Object.keys(e)) r.items.push(t.createPair(s, e[s], n));
|
|
return (
|
|
typeof t.sortMapEntries == 'function' && r.items.sort(t.sortMapEntries),
|
|
r
|
|
);
|
|
}
|
|
var gt = {
|
|
createNode: da,
|
|
default: !0,
|
|
nodeClass: E.YAMLMap,
|
|
tag: 'tag:yaml.org,2002:map',
|
|
resolve: E.resolveMap,
|
|
};
|
|
function ya(t, e, n) {
|
|
let r = new E.YAMLSeq(t);
|
|
if (e && e[Symbol.iterator])
|
|
for (let s of e) {
|
|
let i = t.createNode(s, n.wrapScalars, null, n);
|
|
r.items.push(i);
|
|
}
|
|
return r;
|
|
}
|
|
var Ht = {
|
|
createNode: ya,
|
|
default: !0,
|
|
nodeClass: E.YAMLSeq,
|
|
tag: 'tag:yaml.org,2002:seq',
|
|
resolve: E.resolveSeq,
|
|
},
|
|
Ea = {
|
|
identify: (t) => typeof t == 'string',
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:str',
|
|
resolve: E.resolveString,
|
|
stringify(t, e, n, r) {
|
|
return (
|
|
(e = Object.assign({ actualString: !0 }, e)),
|
|
E.stringifyString(t, e, n, r)
|
|
);
|
|
},
|
|
options: E.strOptions,
|
|
},
|
|
Gn = [gt, Ht, Ea],
|
|
Xt = (t) => typeof t == 'bigint' || Number.isInteger(t),
|
|
Hn = (t, e, n) => (E.intOptions.asBigInt ? BigInt(t) : parseInt(e, n));
|
|
function Zs(t, e, n) {
|
|
let { value: r } = t;
|
|
return Xt(r) && r >= 0 ? n + r.toString(e) : E.stringifyNumber(t);
|
|
}
|
|
var ei = {
|
|
identify: (t) => t == null,
|
|
createNode: (t, e, n) => (n.wrapScalars ? new E.Scalar(null) : null),
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:null',
|
|
test: /^(?:~|[Nn]ull|NULL)?$/,
|
|
resolve: () => null,
|
|
options: E.nullOptions,
|
|
stringify: () => E.nullOptions.nullStr,
|
|
},
|
|
ti = {
|
|
identify: (t) => typeof t == 'boolean',
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:bool',
|
|
test: /^(?:[Tt]rue|TRUE|[Ff]alse|FALSE)$/,
|
|
resolve: (t) => t[0] === 't' || t[0] === 'T',
|
|
options: E.boolOptions,
|
|
stringify: ({ value: t }) =>
|
|
t ? E.boolOptions.trueStr : E.boolOptions.falseStr,
|
|
},
|
|
ni = {
|
|
identify: (t) => Xt(t) && t >= 0,
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:int',
|
|
format: 'OCT',
|
|
test: /^0o([0-7]+)$/,
|
|
resolve: (t, e) => Hn(t, e, 8),
|
|
options: E.intOptions,
|
|
stringify: (t) => Zs(t, 8, '0o'),
|
|
},
|
|
ri = {
|
|
identify: Xt,
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:int',
|
|
test: /^[-+]?[0-9]+$/,
|
|
resolve: (t) => Hn(t, t, 10),
|
|
options: E.intOptions,
|
|
stringify: E.stringifyNumber,
|
|
},
|
|
si = {
|
|
identify: (t) => Xt(t) && t >= 0,
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:int',
|
|
format: 'HEX',
|
|
test: /^0x([0-9a-fA-F]+)$/,
|
|
resolve: (t, e) => Hn(t, e, 16),
|
|
options: E.intOptions,
|
|
stringify: (t) => Zs(t, 16, '0x'),
|
|
},
|
|
ii = {
|
|
identify: (t) => typeof t == 'number',
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:float',
|
|
test: /^(?:[-+]?\.inf|(\.nan))$/i,
|
|
resolve: (t, e) =>
|
|
e ? NaN
|
|
: t[0] === '-' ? Number.NEGATIVE_INFINITY
|
|
: Number.POSITIVE_INFINITY,
|
|
stringify: E.stringifyNumber,
|
|
},
|
|
oi = {
|
|
identify: (t) => typeof t == 'number',
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:float',
|
|
format: 'EXP',
|
|
test: /^[-+]?(?:\.[0-9]+|[0-9]+(?:\.[0-9]*)?)[eE][-+]?[0-9]+$/,
|
|
resolve: (t) => parseFloat(t),
|
|
stringify: ({ value: t }) => Number(t).toExponential(),
|
|
},
|
|
ai = {
|
|
identify: (t) => typeof t == 'number',
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:float',
|
|
test: /^[-+]?(?:\.([0-9]+)|[0-9]+\.([0-9]*))$/,
|
|
resolve(t, e, n) {
|
|
let r = e || n,
|
|
s = new E.Scalar(parseFloat(t));
|
|
return (
|
|
r && r[r.length - 1] === '0' && (s.minFractionDigits = r.length), s
|
|
);
|
|
},
|
|
stringify: E.stringifyNumber,
|
|
},
|
|
Sa = Gn.concat([ei, ti, ni, ri, si, ii, oi, ai]),
|
|
Xs = (t) => typeof t == 'bigint' || Number.isInteger(t),
|
|
Qt = ({ value: t }) => JSON.stringify(t),
|
|
ci = [
|
|
gt,
|
|
Ht,
|
|
{
|
|
identify: (t) => typeof t == 'string',
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:str',
|
|
resolve: E.resolveString,
|
|
stringify: Qt,
|
|
},
|
|
{
|
|
identify: (t) => t == null,
|
|
createNode: (t, e, n) => (n.wrapScalars ? new E.Scalar(null) : null),
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:null',
|
|
test: /^null$/,
|
|
resolve: () => null,
|
|
stringify: Qt,
|
|
},
|
|
{
|
|
identify: (t) => typeof t == 'boolean',
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:bool',
|
|
test: /^true|false$/,
|
|
resolve: (t) => t === 'true',
|
|
stringify: Qt,
|
|
},
|
|
{
|
|
identify: Xs,
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:int',
|
|
test: /^-?(?:0|[1-9][0-9]*)$/,
|
|
resolve: (t) => (E.intOptions.asBigInt ? BigInt(t) : parseInt(t, 10)),
|
|
stringify: ({ value: t }) =>
|
|
Xs(t) ? t.toString() : JSON.stringify(t),
|
|
},
|
|
{
|
|
identify: (t) => typeof t == 'number',
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:float',
|
|
test: /^-?(?:0|[1-9][0-9]*)(?:\.[0-9]*)?(?:[eE][-+]?[0-9]+)?$/,
|
|
resolve: (t) => parseFloat(t),
|
|
stringify: Qt,
|
|
},
|
|
];
|
|
ci.scalarFallback = (t) => {
|
|
throw new SyntaxError(`Unresolved plain scalar ${JSON.stringify(t)}`);
|
|
};
|
|
var zs = ({ value: t }) =>
|
|
t ? E.boolOptions.trueStr : E.boolOptions.falseStr,
|
|
ht = (t) => typeof t == 'bigint' || Number.isInteger(t);
|
|
function Jt(t, e, n) {
|
|
let r = e.replace(/_/g, '');
|
|
if (E.intOptions.asBigInt) {
|
|
switch (n) {
|
|
case 2:
|
|
r = `0b${r}`;
|
|
break;
|
|
case 8:
|
|
r = `0o${r}`;
|
|
break;
|
|
case 16:
|
|
r = `0x${r}`;
|
|
break;
|
|
}
|
|
let i = BigInt(r);
|
|
return t === '-' ? BigInt(-1) * i : i;
|
|
}
|
|
let s = parseInt(r, n);
|
|
return t === '-' ? -1 * s : s;
|
|
}
|
|
function Jn(t, e, n) {
|
|
let { value: r } = t;
|
|
if (ht(r)) {
|
|
let s = r.toString(e);
|
|
return r < 0 ? '-' + n + s.substr(1) : n + s;
|
|
}
|
|
return E.stringifyNumber(t);
|
|
}
|
|
var wa = Gn.concat(
|
|
[
|
|
{
|
|
identify: (t) => t == null,
|
|
createNode: (t, e, n) =>
|
|
n.wrapScalars ? new E.Scalar(null) : null,
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:null',
|
|
test: /^(?:~|[Nn]ull|NULL)?$/,
|
|
resolve: () => null,
|
|
options: E.nullOptions,
|
|
stringify: () => E.nullOptions.nullStr,
|
|
},
|
|
{
|
|
identify: (t) => typeof t == 'boolean',
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:bool',
|
|
test: /^(?:Y|y|[Yy]es|YES|[Tt]rue|TRUE|[Oo]n|ON)$/,
|
|
resolve: () => !0,
|
|
options: E.boolOptions,
|
|
stringify: zs,
|
|
},
|
|
{
|
|
identify: (t) => typeof t == 'boolean',
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:bool',
|
|
test: /^(?:N|n|[Nn]o|NO|[Ff]alse|FALSE|[Oo]ff|OFF)$/i,
|
|
resolve: () => !1,
|
|
options: E.boolOptions,
|
|
stringify: zs,
|
|
},
|
|
{
|
|
identify: ht,
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:int',
|
|
format: 'BIN',
|
|
test: /^([-+]?)0b([0-1_]+)$/,
|
|
resolve: (t, e, n) => Jt(e, n, 2),
|
|
stringify: (t) => Jn(t, 2, '0b'),
|
|
},
|
|
{
|
|
identify: ht,
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:int',
|
|
format: 'OCT',
|
|
test: /^([-+]?)0([0-7_]+)$/,
|
|
resolve: (t, e, n) => Jt(e, n, 8),
|
|
stringify: (t) => Jn(t, 8, '0'),
|
|
},
|
|
{
|
|
identify: ht,
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:int',
|
|
test: /^([-+]?)([0-9][0-9_]*)$/,
|
|
resolve: (t, e, n) => Jt(e, n, 10),
|
|
stringify: E.stringifyNumber,
|
|
},
|
|
{
|
|
identify: ht,
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:int',
|
|
format: 'HEX',
|
|
test: /^([-+]?)0x([0-9a-fA-F_]+)$/,
|
|
resolve: (t, e, n) => Jt(e, n, 16),
|
|
stringify: (t) => Jn(t, 16, '0x'),
|
|
},
|
|
{
|
|
identify: (t) => typeof t == 'number',
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:float',
|
|
test: /^(?:[-+]?\.inf|(\.nan))$/i,
|
|
resolve: (t, e) =>
|
|
e ? NaN
|
|
: t[0] === '-' ? Number.NEGATIVE_INFINITY
|
|
: Number.POSITIVE_INFINITY,
|
|
stringify: E.stringifyNumber,
|
|
},
|
|
{
|
|
identify: (t) => typeof t == 'number',
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:float',
|
|
format: 'EXP',
|
|
test: /^[-+]?([0-9][0-9_]*)?(\.[0-9_]*)?[eE][-+]?[0-9]+$/,
|
|
resolve: (t) => parseFloat(t.replace(/_/g, '')),
|
|
stringify: ({ value: t }) => Number(t).toExponential(),
|
|
},
|
|
{
|
|
identify: (t) => typeof t == 'number',
|
|
default: !0,
|
|
tag: 'tag:yaml.org,2002:float',
|
|
test: /^[-+]?(?:[0-9][0-9_]*)?\.([0-9_]*)$/,
|
|
resolve(t, e) {
|
|
let n = new E.Scalar(parseFloat(t.replace(/_/g, '')));
|
|
if (e) {
|
|
let r = e.replace(/_/g, '');
|
|
r[r.length - 1] === '0' && (n.minFractionDigits = r.length);
|
|
}
|
|
return n;
|
|
},
|
|
stringify: E.stringifyNumber,
|
|
},
|
|
],
|
|
D.binary,
|
|
D.omap,
|
|
D.pairs,
|
|
D.set,
|
|
D.intTime,
|
|
D.floatTime,
|
|
D.timestamp
|
|
),
|
|
ba = { core: Sa, failsafe: Gn, json: ci, yaml11: wa },
|
|
Na = {
|
|
binary: D.binary,
|
|
bool: ti,
|
|
float: ai,
|
|
floatExp: oi,
|
|
floatNaN: ii,
|
|
floatTime: D.floatTime,
|
|
int: ri,
|
|
intHex: si,
|
|
intOct: ni,
|
|
intTime: D.intTime,
|
|
map: gt,
|
|
null: ei,
|
|
omap: D.omap,
|
|
pairs: D.pairs,
|
|
seq: Ht,
|
|
set: D.set,
|
|
timestamp: D.timestamp,
|
|
};
|
|
function Oa(t, e, n) {
|
|
if (e) {
|
|
let r = n.filter((i) => i.tag === e),
|
|
s = r.find((i) => !i.format) || r[0];
|
|
if (!s) throw new Error(`Tag ${e} not found`);
|
|
return s;
|
|
}
|
|
return n.find(
|
|
(r) =>
|
|
((r.identify && r.identify(t)) ||
|
|
(r.class && t instanceof r.class)) &&
|
|
!r.format
|
|
);
|
|
}
|
|
function La(t, e, n) {
|
|
if (t instanceof E.Node) return t;
|
|
let {
|
|
defaultPrefix: r,
|
|
onTagObj: s,
|
|
prevObjects: i,
|
|
schema: o,
|
|
wrapScalars: a,
|
|
} = n;
|
|
e && e.startsWith('!!') && (e = r + e.slice(2));
|
|
let c = Oa(t, e, o.tags);
|
|
if (!c) {
|
|
if (
|
|
(typeof t.toJSON == 'function' && (t = t.toJSON()),
|
|
!t || typeof t != 'object')
|
|
)
|
|
return a ? new E.Scalar(t) : t;
|
|
c =
|
|
t instanceof Map ? gt
|
|
: t[Symbol.iterator] ? Ht
|
|
: gt;
|
|
}
|
|
s && (s(c), delete n.onTagObj);
|
|
let l = { value: void 0, node: void 0 };
|
|
if (t && typeof t == 'object' && i) {
|
|
let f = i.get(t);
|
|
if (f) {
|
|
let m = new E.Alias(f);
|
|
return n.aliasNodes.push(m), m;
|
|
}
|
|
(l.value = t), i.set(t, l);
|
|
}
|
|
return (
|
|
(l.node =
|
|
c.createNode ? c.createNode(n.schema, t, n)
|
|
: a ? new E.Scalar(t)
|
|
: t),
|
|
e && l.node instanceof E.Node && (l.node.tag = e),
|
|
l.node
|
|
);
|
|
}
|
|
function Aa(t, e, n, r) {
|
|
let s = t[r.replace(/\W/g, '')];
|
|
if (!s) {
|
|
let i = Object.keys(t)
|
|
.map((o) => JSON.stringify(o))
|
|
.join(', ');
|
|
throw new Error(`Unknown schema "${r}"; use one of ${i}`);
|
|
}
|
|
if (Array.isArray(n)) for (let i of n) s = s.concat(i);
|
|
else typeof n == 'function' && (s = n(s.slice()));
|
|
for (let i = 0; i < s.length; ++i) {
|
|
let o = s[i];
|
|
if (typeof o == 'string') {
|
|
let a = e[o];
|
|
if (!a) {
|
|
let c = Object.keys(e)
|
|
.map((l) => JSON.stringify(l))
|
|
.join(', ');
|
|
throw new Error(`Unknown custom tag "${o}"; use one of ${c}`);
|
|
}
|
|
s[i] = a;
|
|
}
|
|
}
|
|
return s;
|
|
}
|
|
var Ta = (t, e) =>
|
|
t.key < e.key ? -1
|
|
: t.key > e.key ? 1
|
|
: 0,
|
|
dt = class t {
|
|
constructor({
|
|
customTags: e,
|
|
merge: n,
|
|
schema: r,
|
|
sortMapEntries: s,
|
|
tags: i,
|
|
}) {
|
|
(this.merge = !!n),
|
|
(this.name = r),
|
|
(this.sortMapEntries = s === !0 ? Ta : s || null),
|
|
!e && i && D.warnOptionDeprecation('tags', 'customTags'),
|
|
(this.tags = Aa(ba, Na, e || i, r));
|
|
}
|
|
createNode(e, n, r, s) {
|
|
let i = {
|
|
defaultPrefix: t.defaultPrefix,
|
|
schema: this,
|
|
wrapScalars: n,
|
|
},
|
|
o = s ? Object.assign(s, i) : i;
|
|
return La(e, r, o);
|
|
}
|
|
createPair(e, n, r) {
|
|
r || (r = { wrapScalars: !0 });
|
|
let s = this.createNode(e, r.wrapScalars, null, r),
|
|
i = this.createNode(n, r.wrapScalars, null, r);
|
|
return new E.Pair(s, i);
|
|
}
|
|
};
|
|
Gt._defineProperty(dt, 'defaultPrefix', Gt.defaultTagPrefix);
|
|
Gt._defineProperty(dt, 'defaultTags', Gt.defaultTags);
|
|
li.Schema = dt;
|
|
});
|
|
var mi = te((tn) => {
|
|
'use strict';
|
|
var Y = le(),
|
|
S = qe(),
|
|
fi = Xn(),
|
|
Ca = {
|
|
anchorPrefix: 'a',
|
|
customTags: null,
|
|
indent: 2,
|
|
indentSeq: !0,
|
|
keepCstNodes: !1,
|
|
keepNodeTypes: !0,
|
|
keepBlobsInJSON: !0,
|
|
mapAsMap: !1,
|
|
maxAliasCount: 100,
|
|
prettyErrors: !1,
|
|
simpleKeys: !1,
|
|
version: '1.2',
|
|
},
|
|
Ma = {
|
|
get binary() {
|
|
return S.binaryOptions;
|
|
},
|
|
set binary(t) {
|
|
Object.assign(S.binaryOptions, t);
|
|
},
|
|
get bool() {
|
|
return S.boolOptions;
|
|
},
|
|
set bool(t) {
|
|
Object.assign(S.boolOptions, t);
|
|
},
|
|
get int() {
|
|
return S.intOptions;
|
|
},
|
|
set int(t) {
|
|
Object.assign(S.intOptions, t);
|
|
},
|
|
get null() {
|
|
return S.nullOptions;
|
|
},
|
|
set null(t) {
|
|
Object.assign(S.nullOptions, t);
|
|
},
|
|
get str() {
|
|
return S.strOptions;
|
|
},
|
|
set str(t) {
|
|
Object.assign(S.strOptions, t);
|
|
},
|
|
},
|
|
pi = {
|
|
'1.0': {
|
|
schema: 'yaml-1.1',
|
|
merge: !0,
|
|
tagPrefixes: [
|
|
{ handle: '!', prefix: Y.defaultTagPrefix },
|
|
{ handle: '!!', prefix: 'tag:private.yaml.org,2002:' },
|
|
],
|
|
},
|
|
1.1: {
|
|
schema: 'yaml-1.1',
|
|
merge: !0,
|
|
tagPrefixes: [
|
|
{ handle: '!', prefix: '!' },
|
|
{ handle: '!!', prefix: Y.defaultTagPrefix },
|
|
],
|
|
},
|
|
1.2: {
|
|
schema: 'core',
|
|
merge: !1,
|
|
tagPrefixes: [
|
|
{ handle: '!', prefix: '!' },
|
|
{ handle: '!!', prefix: Y.defaultTagPrefix },
|
|
],
|
|
},
|
|
};
|
|
function ui(t, e) {
|
|
if ((t.version || t.options.version) === '1.0') {
|
|
let s = e.match(/^tag:private\.yaml\.org,2002:([^:/]+)$/);
|
|
if (s) return '!' + s[1];
|
|
let i = e.match(/^tag:([a-zA-Z0-9-]+)\.yaml\.org,2002:(.*)/);
|
|
return i ? `!${i[1]}/${i[2]}` : `!${e.replace(/^tag:/, '')}`;
|
|
}
|
|
let n = t.tagPrefixes.find((s) => e.indexOf(s.prefix) === 0);
|
|
if (!n) {
|
|
let s = t.getDefaults().tagPrefixes;
|
|
n = s && s.find((i) => e.indexOf(i.prefix) === 0);
|
|
}
|
|
if (!n) return e[0] === '!' ? e : `!<${e}>`;
|
|
let r = e
|
|
.substr(n.prefix.length)
|
|
.replace(
|
|
/[!,[\]{}]/g,
|
|
(s) =>
|
|
({
|
|
'!': '%21',
|
|
',': '%2C',
|
|
'[': '%5B',
|
|
']': '%5D',
|
|
'{': '%7B',
|
|
'}': '%7D',
|
|
})[s]
|
|
);
|
|
return n.handle + r;
|
|
}
|
|
function ka(t, e) {
|
|
if (e instanceof S.Alias) return S.Alias;
|
|
if (e.tag) {
|
|
let s = t.filter((i) => i.tag === e.tag);
|
|
if (s.length > 0) return s.find((i) => i.format === e.format) || s[0];
|
|
}
|
|
let n, r;
|
|
if (e instanceof S.Scalar) {
|
|
r = e.value;
|
|
let s = t.filter(
|
|
(i) =>
|
|
(i.identify && i.identify(r)) || (i.class && r instanceof i.class)
|
|
);
|
|
n = s.find((i) => i.format === e.format) || s.find((i) => !i.format);
|
|
} else
|
|
(r = e), (n = t.find((s) => s.nodeClass && r instanceof s.nodeClass));
|
|
if (!n) {
|
|
let s = r && r.constructor ? r.constructor.name : typeof r;
|
|
throw new Error(`Tag not resolved for ${s} value`);
|
|
}
|
|
return n;
|
|
}
|
|
function va(t, e, { anchors: n, doc: r }) {
|
|
let s = [],
|
|
i = r.anchors.getName(t);
|
|
return (
|
|
i && ((n[i] = t), s.push(`&${i}`)),
|
|
t.tag ? s.push(ui(r, t.tag)) : e.default || s.push(ui(r, e.tag)),
|
|
s.join(' ')
|
|
);
|
|
}
|
|
function zt(t, e, n, r) {
|
|
let { anchors: s, schema: i } = e.doc,
|
|
o;
|
|
if (!(t instanceof S.Node)) {
|
|
let l = {
|
|
aliasNodes: [],
|
|
onTagObj: (f) => (o = f),
|
|
prevObjects: new Map(),
|
|
};
|
|
t = i.createNode(t, !0, null, l);
|
|
for (let f of l.aliasNodes) {
|
|
f.source = f.source.node;
|
|
let m = s.getName(f.source);
|
|
m || ((m = s.newName()), (s.map[m] = f.source));
|
|
}
|
|
}
|
|
if (t instanceof S.Pair) return t.toString(e, n, r);
|
|
o || (o = ka(i.tags, t));
|
|
let a = va(t, o, e);
|
|
a.length > 0 && (e.indentAtStart = (e.indentAtStart || 0) + a.length + 1);
|
|
let c =
|
|
typeof o.stringify == 'function' ? o.stringify(t, e, n, r)
|
|
: t instanceof S.Scalar ? S.stringifyString(t, e, n, r)
|
|
: t.toString(e, n, r);
|
|
return (
|
|
a ?
|
|
t instanceof S.Scalar || c[0] === '{' || c[0] === '[' ?
|
|
`${a} ${c}`
|
|
: `${a}
|
|
${e.indent}${c}`
|
|
: c
|
|
);
|
|
}
|
|
var zn = class t {
|
|
static validAnchorNode(e) {
|
|
return (
|
|
e instanceof S.Scalar ||
|
|
e instanceof S.YAMLSeq ||
|
|
e instanceof S.YAMLMap
|
|
);
|
|
}
|
|
constructor(e) {
|
|
Y._defineProperty(this, 'map', Object.create(null)),
|
|
(this.prefix = e);
|
|
}
|
|
createAlias(e, n) {
|
|
return this.setAnchor(e, n), new S.Alias(e);
|
|
}
|
|
createMergePair(...e) {
|
|
let n = new S.Merge();
|
|
return (
|
|
(n.value.items = e.map((r) => {
|
|
if (r instanceof S.Alias) {
|
|
if (r.source instanceof S.YAMLMap) return r;
|
|
} else if (r instanceof S.YAMLMap) return this.createAlias(r);
|
|
throw new Error(
|
|
'Merge sources must be Map nodes or their Aliases'
|
|
);
|
|
})),
|
|
n
|
|
);
|
|
}
|
|
getName(e) {
|
|
let { map: n } = this;
|
|
return Object.keys(n).find((r) => n[r] === e);
|
|
}
|
|
getNames() {
|
|
return Object.keys(this.map);
|
|
}
|
|
getNode(e) {
|
|
return this.map[e];
|
|
}
|
|
newName(e) {
|
|
e || (e = this.prefix);
|
|
let n = Object.keys(this.map);
|
|
for (let r = 1; ; ++r) {
|
|
let s = `${e}${r}`;
|
|
if (!n.includes(s)) return s;
|
|
}
|
|
}
|
|
resolveNodes() {
|
|
let { map: e, _cstAliases: n } = this;
|
|
Object.keys(e).forEach((r) => {
|
|
e[r] = e[r].resolved;
|
|
}),
|
|
n.forEach((r) => {
|
|
r.source = r.source.resolved;
|
|
}),
|
|
delete this._cstAliases;
|
|
}
|
|
setAnchor(e, n) {
|
|
if (e != null && !t.validAnchorNode(e))
|
|
throw new Error(
|
|
'Anchors may only be set for Scalar, Seq and Map nodes'
|
|
);
|
|
if (n && /[\x00-\x19\s,[\]{}]/.test(n))
|
|
throw new Error(
|
|
'Anchor names must not contain whitespace or control characters'
|
|
);
|
|
let { map: r } = this,
|
|
s = e && Object.keys(r).find((i) => r[i] === e);
|
|
if (s)
|
|
if (n) s !== n && (delete r[s], (r[n] = e));
|
|
else return s;
|
|
else {
|
|
if (!n) {
|
|
if (!e) return null;
|
|
n = this.newName();
|
|
}
|
|
r[n] = e;
|
|
}
|
|
return n;
|
|
}
|
|
},
|
|
Zt = (t, e) => {
|
|
if (t && typeof t == 'object') {
|
|
let { tag: n } = t;
|
|
t instanceof S.Collection ?
|
|
(n && (e[n] = !0), t.items.forEach((r) => Zt(r, e)))
|
|
: t instanceof S.Pair ? (Zt(t.key, e), Zt(t.value, e))
|
|
: t instanceof S.Scalar && n && (e[n] = !0);
|
|
}
|
|
return e;
|
|
},
|
|
Ia = (t) => Object.keys(Zt(t, {}));
|
|
function Pa(t, e) {
|
|
let n = { before: [], after: [] },
|
|
r,
|
|
s = !1;
|
|
for (let i of e)
|
|
if (i.valueRange) {
|
|
if (r !== void 0) {
|
|
let a =
|
|
'Document contains trailing content not separated by a ... or --- line';
|
|
t.errors.push(new Y.YAMLSyntaxError(i, a));
|
|
break;
|
|
}
|
|
let o = S.resolveNode(t, i);
|
|
s && ((o.spaceBefore = !0), (s = !1)), (r = o);
|
|
} else
|
|
i.comment !== null ?
|
|
(r === void 0 ? n.before : n.after).push(i.comment)
|
|
: i.type === Y.Type.BLANK_LINE &&
|
|
((s = !0),
|
|
r === void 0 &&
|
|
n.before.length > 0 &&
|
|
!t.commentBefore &&
|
|
((t.commentBefore = n.before.join(`
|
|
`)),
|
|
(n.before = [])));
|
|
if (((t.contents = r || null), !r))
|
|
t.comment =
|
|
n.before.concat(n.after).join(`
|
|
`) || null;
|
|
else {
|
|
let i = n.before.join(`
|
|
`);
|
|
if (i) {
|
|
let o = r instanceof S.Collection && r.items[0] ? r.items[0] : r;
|
|
o.commentBefore =
|
|
o.commentBefore ?
|
|
`${i}
|
|
${o.commentBefore}`
|
|
: i;
|
|
}
|
|
t.comment =
|
|
n.after.join(`
|
|
`) || null;
|
|
}
|
|
}
|
|
function _a({ tagPrefixes: t }, e) {
|
|
let [n, r] = e.parameters;
|
|
if (!n || !r) {
|
|
let s = 'Insufficient parameters given for %TAG directive';
|
|
throw new Y.YAMLSemanticError(e, s);
|
|
}
|
|
if (t.some((s) => s.handle === n)) {
|
|
let s =
|
|
'The %TAG directive must only be given at most once per handle in the same document.';
|
|
throw new Y.YAMLSemanticError(e, s);
|
|
}
|
|
return { handle: n, prefix: r };
|
|
}
|
|
function xa(t, e) {
|
|
let [n] = e.parameters;
|
|
if ((e.name === 'YAML:1.0' && (n = '1.0'), !n)) {
|
|
let r = 'Insufficient parameters given for %YAML directive';
|
|
throw new Y.YAMLSemanticError(e, r);
|
|
}
|
|
if (!pi[n]) {
|
|
let s = `Document will be parsed as YAML ${t.version || t.options.version} rather than YAML ${n}`;
|
|
t.warnings.push(new Y.YAMLWarning(e, s));
|
|
}
|
|
return n;
|
|
}
|
|
function Ra(t, e, n) {
|
|
let r = [],
|
|
s = !1;
|
|
for (let i of e) {
|
|
let { comment: o, name: a } = i;
|
|
switch (a) {
|
|
case 'TAG':
|
|
try {
|
|
t.tagPrefixes.push(_a(t, i));
|
|
} catch (c) {
|
|
t.errors.push(c);
|
|
}
|
|
s = !0;
|
|
break;
|
|
case 'YAML':
|
|
case 'YAML:1.0':
|
|
if (t.version) {
|
|
let c =
|
|
'The %YAML directive must only be given at most once per document.';
|
|
t.errors.push(new Y.YAMLSemanticError(i, c));
|
|
}
|
|
try {
|
|
t.version = xa(t, i);
|
|
} catch (c) {
|
|
t.errors.push(c);
|
|
}
|
|
s = !0;
|
|
break;
|
|
default:
|
|
if (a) {
|
|
let c = `YAML only supports %TAG and %YAML directives, and not %${a}`;
|
|
t.warnings.push(new Y.YAMLWarning(i, c));
|
|
}
|
|
}
|
|
o && r.push(o);
|
|
}
|
|
if (n && !s && (t.version || n.version || t.options.version) === '1.1') {
|
|
let i = ({ handle: o, prefix: a }) => ({ handle: o, prefix: a });
|
|
(t.tagPrefixes = n.tagPrefixes.map(i)), (t.version = n.version);
|
|
}
|
|
t.commentBefore =
|
|
r.join(`
|
|
`) || null;
|
|
}
|
|
function Ve(t) {
|
|
if (t instanceof S.Collection) return !0;
|
|
throw new Error('Expected a YAML collection as document contents');
|
|
}
|
|
var en = class t {
|
|
constructor(e) {
|
|
(this.anchors = new zn(e.anchorPrefix)),
|
|
(this.commentBefore = null),
|
|
(this.comment = null),
|
|
(this.contents = null),
|
|
(this.directivesEndMarker = null),
|
|
(this.errors = []),
|
|
(this.options = e),
|
|
(this.schema = null),
|
|
(this.tagPrefixes = []),
|
|
(this.version = null),
|
|
(this.warnings = []);
|
|
}
|
|
add(e) {
|
|
return Ve(this.contents), this.contents.add(e);
|
|
}
|
|
addIn(e, n) {
|
|
Ve(this.contents), this.contents.addIn(e, n);
|
|
}
|
|
delete(e) {
|
|
return Ve(this.contents), this.contents.delete(e);
|
|
}
|
|
deleteIn(e) {
|
|
return (
|
|
S.isEmptyPath(e) ?
|
|
this.contents == null ?
|
|
!1
|
|
: ((this.contents = null), !0)
|
|
: (Ve(this.contents), this.contents.deleteIn(e))
|
|
);
|
|
}
|
|
getDefaults() {
|
|
return (
|
|
t.defaults[this.version] || t.defaults[this.options.version] || {}
|
|
);
|
|
}
|
|
get(e, n) {
|
|
return this.contents instanceof S.Collection ?
|
|
this.contents.get(e, n)
|
|
: void 0;
|
|
}
|
|
getIn(e, n) {
|
|
return (
|
|
S.isEmptyPath(e) ?
|
|
!n && this.contents instanceof S.Scalar ?
|
|
this.contents.value
|
|
: this.contents
|
|
: this.contents instanceof S.Collection ? this.contents.getIn(e, n)
|
|
: void 0
|
|
);
|
|
}
|
|
has(e) {
|
|
return this.contents instanceof S.Collection ?
|
|
this.contents.has(e)
|
|
: !1;
|
|
}
|
|
hasIn(e) {
|
|
return (
|
|
S.isEmptyPath(e) ? this.contents !== void 0
|
|
: this.contents instanceof S.Collection ? this.contents.hasIn(e)
|
|
: !1
|
|
);
|
|
}
|
|
set(e, n) {
|
|
Ve(this.contents), this.contents.set(e, n);
|
|
}
|
|
setIn(e, n) {
|
|
S.isEmptyPath(e) ?
|
|
(this.contents = n)
|
|
: (Ve(this.contents), this.contents.setIn(e, n));
|
|
}
|
|
setSchema(e, n) {
|
|
if (!e && !n && this.schema) return;
|
|
typeof e == 'number' && (e = e.toFixed(1)),
|
|
e === '1.0' || e === '1.1' || e === '1.2' ?
|
|
(this.version ? (this.version = e) : (this.options.version = e),
|
|
delete this.options.schema)
|
|
: e && typeof e == 'string' && (this.options.schema = e),
|
|
Array.isArray(n) && (this.options.customTags = n);
|
|
let r = Object.assign({}, this.getDefaults(), this.options);
|
|
this.schema = new fi.Schema(r);
|
|
}
|
|
parse(e, n) {
|
|
this.options.keepCstNodes && (this.cstNode = e),
|
|
this.options.keepNodeTypes && (this.type = 'DOCUMENT');
|
|
let {
|
|
directives: r = [],
|
|
contents: s = [],
|
|
directivesEndMarker: i,
|
|
error: o,
|
|
valueRange: a,
|
|
} = e;
|
|
if (
|
|
(o && (o.source || (o.source = this), this.errors.push(o)),
|
|
Ra(this, r, n),
|
|
i && (this.directivesEndMarker = !0),
|
|
(this.range = a ? [a.start, a.end] : null),
|
|
this.setSchema(),
|
|
(this.anchors._cstAliases = []),
|
|
Pa(this, s),
|
|
this.anchors.resolveNodes(),
|
|
this.options.prettyErrors)
|
|
) {
|
|
for (let c of this.errors) c instanceof Y.YAMLError && c.makePretty();
|
|
for (let c of this.warnings)
|
|
c instanceof Y.YAMLError && c.makePretty();
|
|
}
|
|
return this;
|
|
}
|
|
listNonDefaultTags() {
|
|
return Ia(this.contents).filter(
|
|
(e) => e.indexOf(fi.Schema.defaultPrefix) !== 0
|
|
);
|
|
}
|
|
setTagPrefix(e, n) {
|
|
if (e[0] !== '!' || e[e.length - 1] !== '!')
|
|
throw new Error('Handle must start and end with !');
|
|
if (n) {
|
|
let r = this.tagPrefixes.find((s) => s.handle === e);
|
|
r ? (r.prefix = n) : this.tagPrefixes.push({ handle: e, prefix: n });
|
|
} else
|
|
this.tagPrefixes = this.tagPrefixes.filter((r) => r.handle !== e);
|
|
}
|
|
toJSON(e, n) {
|
|
let {
|
|
keepBlobsInJSON: r,
|
|
mapAsMap: s,
|
|
maxAliasCount: i,
|
|
} = this.options,
|
|
o =
|
|
r && (typeof e != 'string' || !(this.contents instanceof S.Scalar)),
|
|
a = {
|
|
doc: this,
|
|
indentStep: ' ',
|
|
keep: o,
|
|
mapAsMap: o && !!s,
|
|
maxAliasCount: i,
|
|
stringify: zt,
|
|
},
|
|
c = Object.keys(this.anchors.map);
|
|
c.length > 0 &&
|
|
(a.anchors = new Map(
|
|
c.map((f) => [
|
|
this.anchors.map[f],
|
|
{ alias: [], aliasCount: 0, count: 1 },
|
|
])
|
|
));
|
|
let l = S.toJSON(this.contents, e, a);
|
|
if (typeof n == 'function' && a.anchors)
|
|
for (let { count: f, res: m } of a.anchors.values()) n(m, f);
|
|
return l;
|
|
}
|
|
toString() {
|
|
if (this.errors.length > 0)
|
|
throw new Error('Document with errors cannot be stringified');
|
|
let e = this.options.indent;
|
|
if (!Number.isInteger(e) || e <= 0) {
|
|
let c = JSON.stringify(e);
|
|
throw new Error(
|
|
`"indent" option must be a positive integer, not ${c}`
|
|
);
|
|
}
|
|
this.setSchema();
|
|
let n = [],
|
|
r = !1;
|
|
if (this.version) {
|
|
let c = '%YAML 1.2';
|
|
this.schema.name === 'yaml-1.1' &&
|
|
(this.version === '1.0' ?
|
|
(c = '%YAML:1.0')
|
|
: this.version === '1.1' && (c = '%YAML 1.1')),
|
|
n.push(c),
|
|
(r = !0);
|
|
}
|
|
let s = this.listNonDefaultTags();
|
|
this.tagPrefixes.forEach(({ handle: c, prefix: l }) => {
|
|
s.some((f) => f.indexOf(l) === 0) &&
|
|
(n.push(`%TAG ${c} ${l}`), (r = !0));
|
|
}),
|
|
(r || this.directivesEndMarker) && n.push('---'),
|
|
this.commentBefore &&
|
|
((r || !this.directivesEndMarker) && n.unshift(''),
|
|
n.unshift(this.commentBefore.replace(/^/gm, '#')));
|
|
let i = {
|
|
anchors: Object.create(null),
|
|
doc: this,
|
|
indent: '',
|
|
indentStep: ' '.repeat(e),
|
|
stringify: zt,
|
|
},
|
|
o = !1,
|
|
a = null;
|
|
if (this.contents) {
|
|
this.contents instanceof S.Node &&
|
|
(this.contents.spaceBefore &&
|
|
(r || this.directivesEndMarker) &&
|
|
n.push(''),
|
|
this.contents.commentBefore &&
|
|
n.push(this.contents.commentBefore.replace(/^/gm, '#')),
|
|
(i.forceBlockIndent = !!this.comment),
|
|
(a = this.contents.comment));
|
|
let c = a ? null : () => (o = !0),
|
|
l = zt(this.contents, i, () => (a = null), c);
|
|
n.push(S.addComment(l, '', a));
|
|
} else this.contents !== void 0 && n.push(zt(this.contents, i));
|
|
return (
|
|
this.comment &&
|
|
((!o || a) && n[n.length - 1] !== '' && n.push(''),
|
|
n.push(this.comment.replace(/^/gm, '#'))),
|
|
n.join(`
|
|
`) +
|
|
`
|
|
`
|
|
);
|
|
}
|
|
};
|
|
Y._defineProperty(en, 'defaults', pi);
|
|
tn.Document = en;
|
|
tn.defaultOptions = Ca;
|
|
tn.scalarOptions = Ma;
|
|
});
|
|
var di = te((gi) => {
|
|
'use strict';
|
|
var Zn = Rs(),
|
|
Oe = mi(),
|
|
Da = Xn(),
|
|
Ya = le(),
|
|
$a = Qn();
|
|
qe();
|
|
function Ba(t, e = !0, n) {
|
|
n === void 0 && typeof e == 'string' && ((n = e), (e = !0));
|
|
let r = Object.assign(
|
|
{},
|
|
Oe.Document.defaults[Oe.defaultOptions.version],
|
|
Oe.defaultOptions
|
|
);
|
|
return new Da.Schema(r).createNode(t, e, n);
|
|
}
|
|
var We = class extends Oe.Document {
|
|
constructor(e) {
|
|
super(Object.assign({}, Oe.defaultOptions, e));
|
|
}
|
|
};
|
|
function Fa(t, e) {
|
|
let n = [],
|
|
r;
|
|
for (let s of Zn.parse(t)) {
|
|
let i = new We(e);
|
|
i.parse(s, r), n.push(i), (r = i);
|
|
}
|
|
return n;
|
|
}
|
|
function hi(t, e) {
|
|
let n = Zn.parse(t),
|
|
r = new We(e).parse(n[0]);
|
|
if (n.length > 1) {
|
|
let s =
|
|
'Source contains multiple documents; please use YAML.parseAllDocuments()';
|
|
r.errors.unshift(new Ya.YAMLSemanticError(n[1], s));
|
|
}
|
|
return r;
|
|
}
|
|
function qa(t, e) {
|
|
let n = hi(t, e);
|
|
if ((n.warnings.forEach((r) => $a.warn(r)), n.errors.length > 0))
|
|
throw n.errors[0];
|
|
return n.toJSON();
|
|
}
|
|
function Ua(t, e) {
|
|
let n = new We(e);
|
|
return (n.contents = t), String(n);
|
|
}
|
|
var Ka = {
|
|
createNode: Ba,
|
|
defaultOptions: Oe.defaultOptions,
|
|
Document: We,
|
|
parse: qa,
|
|
parseAllDocuments: Fa,
|
|
parseCST: Zn.parse,
|
|
parseDocument: hi,
|
|
scalarOptions: Oe.scalarOptions,
|
|
stringify: Ua,
|
|
};
|
|
gi.YAML = Ka;
|
|
});
|
|
var Ei = te((Um, yi) => {
|
|
yi.exports = di().YAML;
|
|
});
|
|
var Si = te((J) => {
|
|
'use strict';
|
|
var je = qe(),
|
|
Qe = le();
|
|
J.findPair = je.findPair;
|
|
J.parseMap = je.resolveMap;
|
|
J.parseSeq = je.resolveSeq;
|
|
J.stringifyNumber = je.stringifyNumber;
|
|
J.stringifyString = je.stringifyString;
|
|
J.toJSON = je.toJSON;
|
|
J.Type = Qe.Type;
|
|
J.YAMLError = Qe.YAMLError;
|
|
J.YAMLReferenceError = Qe.YAMLReferenceError;
|
|
J.YAMLSemanticError = Qe.YAMLSemanticError;
|
|
J.YAMLSyntaxError = Qe.YAMLSyntaxError;
|
|
J.YAMLWarning = Qe.YAMLWarning;
|
|
});
|
|
var Xa = {};
|
|
nr(Xa, {
|
|
languages: () => _r,
|
|
options: () => xr,
|
|
parsers: () => tr,
|
|
printers: () => Ha,
|
|
});
|
|
var Pi = (t, e, n, r) => {
|
|
if (!(t && e == null))
|
|
return (
|
|
e.replaceAll ? e.replaceAll(n, r)
|
|
: n.global ? e.replace(n, r)
|
|
: e.split(n).join(r)
|
|
);
|
|
},
|
|
Et = Pi;
|
|
var Le = 'string',
|
|
Je = 'array',
|
|
Ge = 'cursor',
|
|
He = 'indent',
|
|
Ae = 'align',
|
|
Xe = 'trim',
|
|
Te = 'group',
|
|
Ce = 'fill',
|
|
he = 'if-break',
|
|
ze = 'indent-if-break',
|
|
Me = 'line-suffix',
|
|
Ze = 'line-suffix-boundary',
|
|
Z = 'line',
|
|
et = 'label',
|
|
ke = 'break-parent',
|
|
St = new Set([Ge, He, Ae, Xe, Te, Ce, he, ze, Me, Ze, Z, et, ke]);
|
|
var _i = (t, e, n) => {
|
|
if (!(t && e == null))
|
|
return Array.isArray(e) || typeof e == 'string' ?
|
|
e[n < 0 ? e.length + n : n]
|
|
: e.at(n);
|
|
},
|
|
x = _i;
|
|
function xi(t) {
|
|
if (typeof t == 'string') return Le;
|
|
if (Array.isArray(t)) return Je;
|
|
if (!t) return;
|
|
let { type: e } = t;
|
|
if (St.has(e)) return e;
|
|
}
|
|
var ve = xi;
|
|
var Ri = (t) =>
|
|
new Intl.ListFormat('en-US', { type: 'disjunction' }).format(t);
|
|
function Di(t) {
|
|
let e = t === null ? 'null' : typeof t;
|
|
if (e !== 'string' && e !== 'object')
|
|
return `Unexpected doc '${e}',
|
|
Expected it to be 'string' or 'object'.`;
|
|
if (ve(t)) throw new Error('doc is valid.');
|
|
let n = Object.prototype.toString.call(t);
|
|
if (n !== '[object Object]') return `Unexpected doc '${n}'.`;
|
|
let r = Ri([...St].map((s) => `'${s}'`));
|
|
return `Unexpected doc.type '${t.type}'.
|
|
Expected it to be ${r}.`;
|
|
}
|
|
var nn = class extends Error {
|
|
name = 'InvalidDocError';
|
|
constructor(e) {
|
|
super(Di(e)), (this.doc = e);
|
|
}
|
|
},
|
|
rn = nn;
|
|
function $i(t, e) {
|
|
if (typeof t == 'string') return e(t);
|
|
let n = new Map();
|
|
return r(t);
|
|
function r(i) {
|
|
if (n.has(i)) return n.get(i);
|
|
let o = s(i);
|
|
return n.set(i, o), o;
|
|
}
|
|
function s(i) {
|
|
switch (ve(i)) {
|
|
case Je:
|
|
return e(i.map(r));
|
|
case Ce:
|
|
return e({ ...i, parts: i.parts.map(r) });
|
|
case he:
|
|
return e({
|
|
...i,
|
|
breakContents: r(i.breakContents),
|
|
flatContents: r(i.flatContents),
|
|
});
|
|
case Te: {
|
|
let { expandedStates: o, contents: a } = i;
|
|
return (
|
|
o ? ((o = o.map(r)), (a = o[0])) : (a = r(a)),
|
|
e({ ...i, contents: a, expandedStates: o })
|
|
);
|
|
}
|
|
case Ae:
|
|
case He:
|
|
case ze:
|
|
case et:
|
|
case Me:
|
|
return e({ ...i, contents: r(i.contents) });
|
|
case Le:
|
|
case Ge:
|
|
case Xe:
|
|
case Ze:
|
|
case Z:
|
|
case ke:
|
|
return e(i);
|
|
default:
|
|
throw new rn(i);
|
|
}
|
|
}
|
|
}
|
|
function ir(t, e = tt) {
|
|
return $i(t, (n) =>
|
|
typeof n == 'string' ?
|
|
v(
|
|
e,
|
|
n.split(`
|
|
`)
|
|
)
|
|
: n
|
|
);
|
|
}
|
|
var sn = () => {},
|
|
ge = sn,
|
|
on = sn,
|
|
or = sn;
|
|
function nt(t, e) {
|
|
return ge(e), { type: Ae, contents: e, n: t };
|
|
}
|
|
function Ie(t, e = {}) {
|
|
return (
|
|
ge(t),
|
|
on(e.expandedStates, !0),
|
|
{
|
|
type: Te,
|
|
id: e.id,
|
|
contents: t,
|
|
break: !!e.shouldBreak,
|
|
expandedStates: e.expandedStates,
|
|
}
|
|
);
|
|
}
|
|
function an(t) {
|
|
return nt(Number.NEGATIVE_INFINITY, t);
|
|
}
|
|
function ar(t) {
|
|
return nt({ type: 'root' }, t);
|
|
}
|
|
function cr(t) {
|
|
return nt(-1, t);
|
|
}
|
|
function cn(t, e) {
|
|
return Ie(t[0], { ...e, expandedStates: t });
|
|
}
|
|
function wt(t) {
|
|
return or(t), { type: Ce, parts: t };
|
|
}
|
|
function rt(t, e = '', n = {}) {
|
|
return (
|
|
ge(t),
|
|
e !== '' && ge(e),
|
|
{ type: he, breakContents: t, flatContents: e, groupId: n.groupId }
|
|
);
|
|
}
|
|
function lr(t) {
|
|
return ge(t), { type: Me, contents: t };
|
|
}
|
|
var bt = { type: ke };
|
|
var Bi = { type: Z, hard: !0 },
|
|
Fi = { type: Z, hard: !0, literal: !0 },
|
|
ne = { type: Z },
|
|
Nt = { type: Z, soft: !0 },
|
|
N = [Bi, bt],
|
|
tt = [Fi, bt];
|
|
function v(t, e) {
|
|
ge(t), on(e);
|
|
let n = [];
|
|
for (let r = 0; r < e.length; r++) r !== 0 && n.push(t), n.push(e[r]);
|
|
return n;
|
|
}
|
|
function Ot(t) {
|
|
return (e, n, r) => {
|
|
let s = !!(r != null && r.backwards);
|
|
if (n === !1) return !1;
|
|
let { length: i } = e,
|
|
o = n;
|
|
for (; o >= 0 && o < i; ) {
|
|
let a = e.charAt(o);
|
|
if (t instanceof RegExp) {
|
|
if (!t.test(a)) return o;
|
|
} else if (!t.includes(a)) return o;
|
|
s ? o-- : o++;
|
|
}
|
|
return o === -1 || o === i ? o : !1;
|
|
};
|
|
}
|
|
var kc = Ot(/\s/u),
|
|
ln = Ot(' '),
|
|
vc = Ot(',; '),
|
|
Ic = Ot(/[^\n\r]/u);
|
|
function qi(t, e, n) {
|
|
let r = !!(n != null && n.backwards);
|
|
if (e === !1) return !1;
|
|
let s = t.charAt(e);
|
|
if (r) {
|
|
if (
|
|
t.charAt(e - 1) === '\r' &&
|
|
s ===
|
|
`
|
|
`
|
|
)
|
|
return e - 2;
|
|
if (
|
|
s ===
|
|
`
|
|
` ||
|
|
s === '\r' ||
|
|
s === '\u2028' ||
|
|
s === '\u2029'
|
|
)
|
|
return e - 1;
|
|
} else {
|
|
if (
|
|
s === '\r' &&
|
|
t.charAt(e + 1) ===
|
|
`
|
|
`
|
|
)
|
|
return e + 2;
|
|
if (
|
|
s ===
|
|
`
|
|
` ||
|
|
s === '\r' ||
|
|
s === '\u2028' ||
|
|
s === '\u2029'
|
|
)
|
|
return e + 1;
|
|
}
|
|
return e;
|
|
}
|
|
var fn = qi;
|
|
function Ui(t, e) {
|
|
let n = e - 1;
|
|
(n = ln(t, n, { backwards: !0 })),
|
|
(n = fn(t, n, { backwards: !0 })),
|
|
(n = ln(t, n, { backwards: !0 }));
|
|
let r = fn(t, n, { backwards: !0 });
|
|
return n !== r;
|
|
}
|
|
var fr = Ui;
|
|
var un = class extends Error {
|
|
name = 'UnexpectedNodeError';
|
|
constructor(e, n, r = 'type') {
|
|
super(`Unexpected ${n} node ${r}: ${JSON.stringify(e[r])}.`),
|
|
(this.node = e);
|
|
}
|
|
},
|
|
ur = un;
|
|
function pr(t, e) {
|
|
let { node: n } = t;
|
|
if (
|
|
n.type === 'root' &&
|
|
e.filepath &&
|
|
/(?:[/\\]|^)\.(?:prettier|stylelint|lintstaged)rc$/u.test(e.filepath)
|
|
)
|
|
return async (r) => {
|
|
let s = await r(e.originalText, { parser: 'json' });
|
|
return s ? [s, N] : void 0;
|
|
};
|
|
}
|
|
pr.getVisitorKeys = () => [];
|
|
var mr = pr;
|
|
var st = null;
|
|
function it(t) {
|
|
if (st !== null && typeof st.property) {
|
|
let e = st;
|
|
return (st = it.prototype = null), e;
|
|
}
|
|
return (st = it.prototype = t ?? Object.create(null)), new it();
|
|
}
|
|
var Ki = 10;
|
|
for (let t = 0; t <= Ki; t++) it();
|
|
function pn(t) {
|
|
return it(t);
|
|
}
|
|
function Vi(t, e = 'type') {
|
|
pn(t);
|
|
function n(r) {
|
|
let s = r[e],
|
|
i = t[s];
|
|
if (!Array.isArray(i))
|
|
throw Object.assign(new Error(`Missing visitor keys for '${s}'.`), {
|
|
node: r,
|
|
});
|
|
return i;
|
|
}
|
|
return n;
|
|
}
|
|
var hr = Vi;
|
|
var Wi = Object.fromEntries(
|
|
Object.entries({
|
|
root: ['children'],
|
|
document: ['head', 'body', 'children'],
|
|
documentHead: ['children'],
|
|
documentBody: ['children'],
|
|
directive: [],
|
|
alias: [],
|
|
blockLiteral: [],
|
|
blockFolded: ['children'],
|
|
plain: ['children'],
|
|
quoteSingle: [],
|
|
quoteDouble: [],
|
|
mapping: ['children'],
|
|
mappingItem: ['key', 'value', 'children'],
|
|
mappingKey: ['content', 'children'],
|
|
mappingValue: ['content', 'children'],
|
|
sequence: ['children'],
|
|
sequenceItem: ['content', 'children'],
|
|
flowMapping: ['children'],
|
|
flowMappingItem: ['key', 'value', 'children'],
|
|
flowSequence: ['children'],
|
|
flowSequenceItem: ['content', 'children'],
|
|
comment: [],
|
|
tag: [],
|
|
anchor: [],
|
|
}).map(([t, e]) => [
|
|
t,
|
|
[
|
|
...e,
|
|
'anchor',
|
|
'tag',
|
|
'indicatorComment',
|
|
'leadingComments',
|
|
'middleComments',
|
|
'trailingComment',
|
|
'endComments',
|
|
],
|
|
])
|
|
),
|
|
gr = Wi;
|
|
var ji = hr(gr),
|
|
dr = ji;
|
|
function Pe(t) {
|
|
return t.position.start.offset;
|
|
}
|
|
function yr(t) {
|
|
return t.position.end.offset;
|
|
}
|
|
function Er(t) {
|
|
return /^\s*@(?:prettier|format)\s*$/u.test(t);
|
|
}
|
|
function Sr(t) {
|
|
return /^\s*#[^\S\n]*@(?:prettier|format)\s*?(?:\n|$)/u.test(t);
|
|
}
|
|
function wr(t) {
|
|
return `# @format
|
|
|
|
${t}`;
|
|
}
|
|
function Qi(t) {
|
|
return Array.isArray(t) && t.length > 0;
|
|
}
|
|
var _e = Qi;
|
|
function H(t, e) {
|
|
return (
|
|
typeof (t == null ? void 0 : t.type) == 'string' &&
|
|
(!e || e.includes(t.type))
|
|
);
|
|
}
|
|
function mn(t, e, n) {
|
|
return e(
|
|
'children' in t ?
|
|
{ ...t, children: t.children.map((r) => mn(r, e, t)) }
|
|
: t,
|
|
n
|
|
);
|
|
}
|
|
function xe(t, e, n) {
|
|
Object.defineProperty(t, e, { get: n, enumerable: !1 });
|
|
}
|
|
function Nr(t, e) {
|
|
let n = 0,
|
|
r = e.length;
|
|
for (let s = t.position.end.offset - 1; s < r; s++) {
|
|
let i = e[s];
|
|
if (
|
|
(i ===
|
|
`
|
|
` && n++,
|
|
n === 1 && /\S/u.test(i))
|
|
)
|
|
return !1;
|
|
if (n === 2) return !0;
|
|
}
|
|
return !1;
|
|
}
|
|
function Lt(t) {
|
|
let { node: e } = t;
|
|
switch (e.type) {
|
|
case 'tag':
|
|
case 'anchor':
|
|
case 'comment':
|
|
return !1;
|
|
}
|
|
let n = t.stack.length;
|
|
for (let r = 1; r < n; r++) {
|
|
let s = t.stack[r],
|
|
i = t.stack[r - 1];
|
|
if (Array.isArray(i) && typeof s == 'number' && s !== i.length - 1)
|
|
return !1;
|
|
}
|
|
return !0;
|
|
}
|
|
function At(t) {
|
|
return _e(t.children) ? At(x(!1, t.children, -1)) : t;
|
|
}
|
|
function br(t) {
|
|
return t.value.trim() === 'prettier-ignore';
|
|
}
|
|
function Or(t) {
|
|
let { node: e } = t;
|
|
if (e.type === 'documentBody') {
|
|
let n = t.parent.head;
|
|
return R(n) && br(x(!1, n.endComments, -1));
|
|
}
|
|
return ee(e) && br(x(!1, e.leadingComments, -1));
|
|
}
|
|
function Re(t) {
|
|
return !_e(t.children) && !Ji(t);
|
|
}
|
|
function Ji(t) {
|
|
return ee(t) || ie(t) || hn(t) || K(t) || R(t);
|
|
}
|
|
function ee(t) {
|
|
return _e(t == null ? void 0 : t.leadingComments);
|
|
}
|
|
function ie(t) {
|
|
return _e(t == null ? void 0 : t.middleComments);
|
|
}
|
|
function hn(t) {
|
|
return t == null ? void 0 : t.indicatorComment;
|
|
}
|
|
function K(t) {
|
|
return t == null ? void 0 : t.trailingComment;
|
|
}
|
|
function R(t) {
|
|
return _e(t == null ? void 0 : t.endComments);
|
|
}
|
|
function Lr(t) {
|
|
let e = [],
|
|
n;
|
|
for (let r of t.split(/( +)/u))
|
|
r !== ' ' ?
|
|
n === ' ' ?
|
|
e.push(r)
|
|
: e.push((e.pop() || '') + r)
|
|
: n === void 0 && e.unshift(''),
|
|
(n = r);
|
|
return (
|
|
n === ' ' && e.push((e.pop() || '') + ' '),
|
|
e[0] === '' && (e.shift(), e.unshift(' ' + (e.shift() || ''))),
|
|
e
|
|
);
|
|
}
|
|
function Ar(t, e, n) {
|
|
let r = e
|
|
.split(
|
|
`
|
|
`
|
|
)
|
|
.map((s, i, o) =>
|
|
i === 0 && i === o.length - 1 ? s
|
|
: i !== 0 && i !== o.length - 1 ? s.trim()
|
|
: i === 0 ? s.trimEnd()
|
|
: s.trimStart()
|
|
);
|
|
return n.proseWrap === 'preserve' ?
|
|
r.map((s) => (s.length === 0 ? [] : [s]))
|
|
: r
|
|
.map((s) => (s.length === 0 ? [] : Lr(s)))
|
|
.reduce(
|
|
(s, i, o) =>
|
|
(
|
|
o !== 0 &&
|
|
r[o - 1].length > 0 &&
|
|
i.length > 0 &&
|
|
!(t === 'quoteDouble' && x(!1, x(!1, s, -1), -1).endsWith('\\'))
|
|
) ?
|
|
[...s.slice(0, -1), [...x(!1, s, -1), ...i]]
|
|
: [...s, i],
|
|
[]
|
|
)
|
|
.map((s) => (n.proseWrap === 'never' ? [s.join(' ')] : s));
|
|
}
|
|
function Tr(t, { parentIndent: e, isLastDescendant: n, options: r }) {
|
|
let s =
|
|
t.position.start.line === t.position.end.line ?
|
|
''
|
|
: r.originalText
|
|
.slice(t.position.start.offset, t.position.end.offset)
|
|
.match(/^[^\n]*\n(.*)$/su)[1],
|
|
i;
|
|
if (t.indent === null) {
|
|
let c = s.match(/^(?<leadingSpace> *)[^\n\r ]/mu);
|
|
i = c ? c.groups.leadingSpace.length : Number.POSITIVE_INFINITY;
|
|
} else i = t.indent - 1 + e;
|
|
let o = s
|
|
.split(
|
|
`
|
|
`
|
|
)
|
|
.map((c) => c.slice(i));
|
|
if (r.proseWrap === 'preserve' || t.type === 'blockLiteral')
|
|
return a(o.map((c) => (c.length === 0 ? [] : [c])));
|
|
return a(
|
|
o
|
|
.map((c) => (c.length === 0 ? [] : Lr(c)))
|
|
.reduce(
|
|
(c, l, f) =>
|
|
(
|
|
f !== 0 &&
|
|
o[f - 1].length > 0 &&
|
|
l.length > 0 &&
|
|
!/^\s/u.test(l[0]) &&
|
|
!/^\s|\s$/u.test(x(!1, c, -1))
|
|
) ?
|
|
[...c.slice(0, -1), [...x(!1, c, -1), ...l]]
|
|
: [...c, l],
|
|
[]
|
|
)
|
|
.map((c) =>
|
|
c.reduce(
|
|
(l, f) =>
|
|
l.length > 0 && /\s$/u.test(x(!1, l, -1)) ?
|
|
[...l.slice(0, -1), x(!1, l, -1) + ' ' + f]
|
|
: [...l, f],
|
|
[]
|
|
)
|
|
)
|
|
.map((c) => (r.proseWrap === 'never' ? [c.join(' ')] : c))
|
|
);
|
|
function a(c) {
|
|
if (t.chomping === 'keep')
|
|
return x(!1, c, -1).length === 0 ? c.slice(0, -1) : c;
|
|
let l = 0;
|
|
for (let f = c.length - 1; f >= 0 && c[f].length === 0; f--) l++;
|
|
return (
|
|
l === 0 ? c
|
|
: l >= 2 && !n ? c.slice(0, -(l - 1))
|
|
: c.slice(0, -l)
|
|
);
|
|
}
|
|
}
|
|
function ot(t) {
|
|
if (!t) return !0;
|
|
switch (t.type) {
|
|
case 'plain':
|
|
case 'quoteDouble':
|
|
case 'quoteSingle':
|
|
case 'alias':
|
|
case 'flowMapping':
|
|
case 'flowSequence':
|
|
return !0;
|
|
default:
|
|
return !1;
|
|
}
|
|
}
|
|
var gn = new WeakMap();
|
|
function Tt(t, e) {
|
|
let { node: n, root: r } = t,
|
|
s;
|
|
return (
|
|
gn.has(r) ? (s = gn.get(r)) : ((s = new Set()), gn.set(r, s)),
|
|
(
|
|
!s.has(n.position.end.line) &&
|
|
(s.add(n.position.end.line), Nr(n, e) && !dn(t.parent))
|
|
) ?
|
|
Nt
|
|
: ''
|
|
);
|
|
}
|
|
function dn(t) {
|
|
return (
|
|
R(t) &&
|
|
!H(t, ['documentHead', 'documentBody', 'flowMapping', 'flowSequence'])
|
|
);
|
|
}
|
|
function I(t, e) {
|
|
return nt(' '.repeat(t), e);
|
|
}
|
|
function Gi(t, e, n) {
|
|
let { node: r } = t,
|
|
s = t.ancestors.filter(
|
|
(l) => l.type === 'sequence' || l.type === 'mapping'
|
|
).length,
|
|
i = Lt(t),
|
|
o = [r.type === 'blockFolded' ? '>' : '|'];
|
|
r.indent !== null && o.push(r.indent.toString()),
|
|
r.chomping !== 'clip' && o.push(r.chomping === 'keep' ? '+' : '-'),
|
|
hn(r) && o.push(' ', e('indicatorComment'));
|
|
let a = Tr(r, { parentIndent: s, isLastDescendant: i, options: n }),
|
|
c = [];
|
|
for (let [l, f] of a.entries())
|
|
l === 0 && c.push(N),
|
|
c.push(wt(v(ne, f))),
|
|
l !== a.length - 1 ?
|
|
c.push(f.length === 0 ? N : ar(tt))
|
|
: r.chomping === 'keep' && i && c.push(an(f.length === 0 ? N : tt));
|
|
return (
|
|
r.indent === null ?
|
|
o.push(cr(I(n.tabWidth, c)))
|
|
: o.push(an(I(r.indent - 1 + s, c))),
|
|
o
|
|
);
|
|
}
|
|
var Cr = Gi;
|
|
function Ct(t, e, n) {
|
|
let { node: r } = t,
|
|
s = r.type === 'flowMapping',
|
|
i = s ? '{' : '[',
|
|
o = s ? '}' : ']',
|
|
a = Nt;
|
|
s && r.children.length > 0 && n.bracketSpacing && (a = ne);
|
|
let c = x(!1, r.children, -1),
|
|
l =
|
|
(c == null ? void 0 : c.type) === 'flowMappingItem' &&
|
|
Re(c.key) &&
|
|
Re(c.value);
|
|
return [
|
|
i,
|
|
I(n.tabWidth, [
|
|
a,
|
|
Hi(t, e, n),
|
|
n.trailingComma === 'none' ? '' : rt(','),
|
|
R(r) ? [N, v(N, t.map(e, 'endComments'))] : '',
|
|
]),
|
|
l ? '' : a,
|
|
o,
|
|
];
|
|
}
|
|
function Hi(t, e, n) {
|
|
return t.map(
|
|
({ isLast: r, node: s, next: i }) => [
|
|
e(),
|
|
r ? '' : (
|
|
[
|
|
',',
|
|
ne,
|
|
s.position.start.line !== i.position.start.line ?
|
|
Tt(t, n.originalText)
|
|
: '',
|
|
]
|
|
),
|
|
],
|
|
'children'
|
|
);
|
|
}
|
|
function Xi(t, e, n) {
|
|
var C;
|
|
let { node: r, parent: s } = t,
|
|
{ key: i, value: o } = r,
|
|
a = Re(i),
|
|
c = Re(o);
|
|
if (a && c) return ': ';
|
|
let l = e('key'),
|
|
f = zi(r) ? ' ' : '';
|
|
if (c)
|
|
return (
|
|
r.type === 'flowMappingItem' && s.type === 'flowMapping' ? l
|
|
: (
|
|
r.type === 'mappingItem' &&
|
|
yn(i.content, n) &&
|
|
!K(i.content) &&
|
|
((C = s.tag) == null ? void 0 : C.value) !== 'tag:yaml.org,2002:set'
|
|
) ?
|
|
[l, f, ':']
|
|
: ['? ', I(2, l)]
|
|
);
|
|
let m = e('value');
|
|
if (a) return [': ', I(2, m)];
|
|
if (ee(o) || !ot(i.content))
|
|
return [
|
|
'? ',
|
|
I(2, l),
|
|
N,
|
|
...t.map(() => [e(), N], 'value', 'leadingComments'),
|
|
': ',
|
|
I(2, m),
|
|
];
|
|
if (
|
|
Zi(i.content) &&
|
|
!ee(i.content) &&
|
|
!ie(i.content) &&
|
|
!K(i.content) &&
|
|
!R(i) &&
|
|
!ee(o.content) &&
|
|
!ie(o.content) &&
|
|
!R(o) &&
|
|
yn(o.content, n)
|
|
)
|
|
return [l, f, ': ', m];
|
|
let d = Symbol('mappingKey'),
|
|
y = Ie([rt('? '), Ie(I(2, l), { id: d })]),
|
|
h = [N, ': ', I(2, m)],
|
|
g = [f, ':'];
|
|
(
|
|
ee(o.content) ||
|
|
(R(o) && o.content && !H(o.content, ['mapping', 'sequence'])) ||
|
|
(s.type === 'mapping' && K(i.content) && ot(o.content)) ||
|
|
(H(o.content, ['mapping', 'sequence']) &&
|
|
o.content.tag === null &&
|
|
o.content.anchor === null)
|
|
) ?
|
|
g.push(N)
|
|
: o.content ? g.push(ne)
|
|
: K(o) && g.push(' '),
|
|
g.push(m);
|
|
let w = I(n.tabWidth, g);
|
|
return yn(i.content, n) && !ee(i.content) && !ie(i.content) && !R(i) ?
|
|
cn([[l, w]])
|
|
: cn([[y, rt(h, w, { groupId: d })]]);
|
|
}
|
|
function yn(t, e) {
|
|
if (!t) return !0;
|
|
switch (t.type) {
|
|
case 'plain':
|
|
case 'quoteSingle':
|
|
case 'quoteDouble':
|
|
break;
|
|
case 'alias':
|
|
return !0;
|
|
default:
|
|
return !1;
|
|
}
|
|
if (e.proseWrap === 'preserve')
|
|
return t.position.start.line === t.position.end.line;
|
|
if (
|
|
/\\$/mu.test(
|
|
e.originalText.slice(t.position.start.offset, t.position.end.offset)
|
|
)
|
|
)
|
|
return !1;
|
|
switch (e.proseWrap) {
|
|
case 'never':
|
|
return !t.value.includes(`
|
|
`);
|
|
case 'always':
|
|
return !/[\n ]/u.test(t.value);
|
|
default:
|
|
return !1;
|
|
}
|
|
}
|
|
function zi(t) {
|
|
var e;
|
|
return ((e = t.key.content) == null ? void 0 : e.type) === 'alias';
|
|
}
|
|
function Zi(t) {
|
|
if (!t) return !0;
|
|
switch (t.type) {
|
|
case 'plain':
|
|
case 'quoteDouble':
|
|
case 'quoteSingle':
|
|
return t.position.start.line === t.position.end.line;
|
|
case 'alias':
|
|
return !0;
|
|
default:
|
|
return !1;
|
|
}
|
|
}
|
|
var Mr = Xi;
|
|
function eo(t) {
|
|
return mn(t, to);
|
|
}
|
|
function to(t) {
|
|
switch (t.type) {
|
|
case 'document':
|
|
xe(t, 'head', () => t.children[0]), xe(t, 'body', () => t.children[1]);
|
|
break;
|
|
case 'documentBody':
|
|
case 'sequenceItem':
|
|
case 'flowSequenceItem':
|
|
case 'mappingKey':
|
|
case 'mappingValue':
|
|
xe(t, 'content', () => t.children[0]);
|
|
break;
|
|
case 'mappingItem':
|
|
case 'flowMappingItem':
|
|
xe(t, 'key', () => t.children[0]), xe(t, 'value', () => t.children[1]);
|
|
break;
|
|
}
|
|
return t;
|
|
}
|
|
var kr = eo;
|
|
function no(t, e, n) {
|
|
let { node: r } = t,
|
|
s = [];
|
|
r.type !== 'mappingValue' &&
|
|
ee(r) &&
|
|
s.push([v(N, t.map(n, 'leadingComments')), N]);
|
|
let { tag: i, anchor: o } = r;
|
|
i && s.push(n('tag')), i && o && s.push(' '), o && s.push(n('anchor'));
|
|
let a = '';
|
|
return (
|
|
H(r, [
|
|
'mapping',
|
|
'sequence',
|
|
'comment',
|
|
'directive',
|
|
'mappingItem',
|
|
'sequenceItem',
|
|
]) &&
|
|
!Lt(t) &&
|
|
(a = Tt(t, e.originalText)),
|
|
(i || o) &&
|
|
(H(r, ['sequence', 'mapping']) && !ie(r) ? s.push(N) : s.push(' ')),
|
|
ie(r) &&
|
|
s.push([
|
|
r.middleComments.length === 1 ? '' : N,
|
|
v(N, t.map(n, 'middleComments')),
|
|
N,
|
|
]),
|
|
Or(t) ?
|
|
s.push(
|
|
ir(
|
|
e.originalText
|
|
.slice(r.position.start.offset, r.position.end.offset)
|
|
.trimEnd()
|
|
)
|
|
)
|
|
: s.push(Ie(ro(t, e, n))),
|
|
K(r) &&
|
|
!H(r, ['document', 'documentHead']) &&
|
|
s.push(
|
|
lr([
|
|
r.type === 'mappingValue' && !r.content ? '' : ' ',
|
|
(
|
|
t.parent.type === 'mappingKey' &&
|
|
t.getParentNode(2).type === 'mapping' &&
|
|
ot(r)
|
|
) ?
|
|
''
|
|
: bt,
|
|
n('trailingComment'),
|
|
])
|
|
),
|
|
dn(r) &&
|
|
s.push(
|
|
I(r.type === 'sequenceItem' ? 2 : 0, [
|
|
N,
|
|
v(
|
|
N,
|
|
t.map(
|
|
({ node: c }) => [fr(e.originalText, Pe(c)) ? N : '', n()],
|
|
'endComments'
|
|
)
|
|
),
|
|
])
|
|
),
|
|
s.push(a),
|
|
s
|
|
);
|
|
}
|
|
function ro(t, e, n) {
|
|
let { node: r } = t;
|
|
switch (r.type) {
|
|
case 'root': {
|
|
let s = [];
|
|
t.each(({ node: o, next: a, isFirst: c }) => {
|
|
c || s.push(N),
|
|
s.push(n()),
|
|
vr(o, a) ?
|
|
(s.push(N, '...'), K(o) && s.push(' ', n('trailingComment')))
|
|
: a && !K(a.head) && s.push(N, '---');
|
|
}, 'children');
|
|
let i = At(r);
|
|
return (
|
|
(!H(i, ['blockLiteral', 'blockFolded']) || i.chomping !== 'keep') &&
|
|
s.push(N),
|
|
s
|
|
);
|
|
}
|
|
case 'document': {
|
|
let s = [];
|
|
return (
|
|
io(t, e) === 'head' &&
|
|
((r.head.children.length > 0 || r.head.endComments.length > 0) &&
|
|
s.push(n('head')),
|
|
K(r.head) ?
|
|
s.push(['---', ' ', n(['head', 'trailingComment'])])
|
|
: s.push('---')),
|
|
so(r) && s.push(n('body')),
|
|
v(N, s)
|
|
);
|
|
}
|
|
case 'documentHead':
|
|
return v(N, [...t.map(n, 'children'), ...t.map(n, 'endComments')]);
|
|
case 'documentBody': {
|
|
let { children: s, endComments: i } = r,
|
|
o = '';
|
|
if (s.length > 0 && i.length > 0) {
|
|
let a = At(r);
|
|
H(a, ['blockFolded', 'blockLiteral']) ?
|
|
a.chomping !== 'keep' && (o = [N, N])
|
|
: (o = N);
|
|
}
|
|
return [v(N, t.map(n, 'children')), o, v(N, t.map(n, 'endComments'))];
|
|
}
|
|
case 'directive':
|
|
return ['%', v(' ', [r.name, ...r.parameters])];
|
|
case 'comment':
|
|
return ['#', r.value];
|
|
case 'alias':
|
|
return ['*', r.value];
|
|
case 'tag':
|
|
return e.originalText.slice(
|
|
r.position.start.offset,
|
|
r.position.end.offset
|
|
);
|
|
case 'anchor':
|
|
return ['&', r.value];
|
|
case 'plain':
|
|
return at(
|
|
r.type,
|
|
e.originalText.slice(r.position.start.offset, r.position.end.offset),
|
|
e
|
|
);
|
|
case 'quoteDouble':
|
|
case 'quoteSingle': {
|
|
let s = "'",
|
|
i = '"',
|
|
o = e.originalText.slice(
|
|
r.position.start.offset + 1,
|
|
r.position.end.offset - 1
|
|
);
|
|
if (
|
|
(r.type === 'quoteSingle' && o.includes('\\')) ||
|
|
(r.type === 'quoteDouble' && /\\[^"]/u.test(o))
|
|
) {
|
|
let c = r.type === 'quoteDouble' ? i : s;
|
|
return [c, at(r.type, o, e), c];
|
|
}
|
|
if (o.includes(i))
|
|
return [
|
|
s,
|
|
at(
|
|
r.type,
|
|
r.type === 'quoteDouble' ?
|
|
Et(!1, Et(!1, o, String.raw`\"`, i), "'", s.repeat(2))
|
|
: o,
|
|
e
|
|
),
|
|
s,
|
|
];
|
|
if (o.includes(s))
|
|
return [
|
|
i,
|
|
at(r.type, r.type === 'quoteSingle' ? Et(!1, o, "''", s) : o, e),
|
|
i,
|
|
];
|
|
let a = e.singleQuote ? s : i;
|
|
return [a, at(r.type, o, e), a];
|
|
}
|
|
case 'blockFolded':
|
|
case 'blockLiteral':
|
|
return Cr(t, n, e);
|
|
case 'mapping':
|
|
case 'sequence':
|
|
return v(N, t.map(n, 'children'));
|
|
case 'sequenceItem':
|
|
return ['- ', I(2, r.content ? n('content') : '')];
|
|
case 'mappingKey':
|
|
case 'mappingValue':
|
|
return r.content ? n('content') : '';
|
|
case 'mappingItem':
|
|
case 'flowMappingItem':
|
|
return Mr(t, n, e);
|
|
case 'flowMapping':
|
|
return Ct(t, n, e);
|
|
case 'flowSequence':
|
|
return Ct(t, n, e);
|
|
case 'flowSequenceItem':
|
|
return n('content');
|
|
default:
|
|
throw new ur(r, 'YAML');
|
|
}
|
|
}
|
|
function so(t) {
|
|
return t.body.children.length > 0 || R(t.body);
|
|
}
|
|
function vr(t, e) {
|
|
return K(t) || (e && (e.head.children.length > 0 || R(e.head)));
|
|
}
|
|
function io(t, e) {
|
|
let n = t.node;
|
|
if (
|
|
(t.isFirst &&
|
|
/---(?:\s|$)/u.test(e.originalText.slice(Pe(n), Pe(n) + 4))) ||
|
|
n.head.children.length > 0 ||
|
|
R(n.head) ||
|
|
K(n.head)
|
|
)
|
|
return 'head';
|
|
let r = t.next;
|
|
return (
|
|
vr(n, r) ? !1
|
|
: r ? 'root'
|
|
: !1
|
|
);
|
|
}
|
|
function at(t, e, n) {
|
|
let r = Ar(t, e, n);
|
|
return v(
|
|
N,
|
|
r.map((s) => wt(v(ne, s)))
|
|
);
|
|
}
|
|
function Ir(t, e) {
|
|
if (H(t))
|
|
switch (t.type) {
|
|
case 'comment':
|
|
if (Er(t.value)) return null;
|
|
break;
|
|
case 'quoteDouble':
|
|
case 'quoteSingle':
|
|
e.type = 'quote';
|
|
break;
|
|
}
|
|
}
|
|
Ir.ignoredProperties = new Set(['position']);
|
|
var oo = {
|
|
preprocess: kr,
|
|
embed: mr,
|
|
print: no,
|
|
massageAstNode: Ir,
|
|
insertPragma: wr,
|
|
getVisitorKeys: dr,
|
|
},
|
|
Pr = oo;
|
|
var _r = [
|
|
{
|
|
linguistLanguageId: 407,
|
|
name: 'YAML',
|
|
type: 'data',
|
|
color: '#cb171e',
|
|
tmScope: 'source.yaml',
|
|
aliases: ['yml'],
|
|
extensions: [
|
|
'.yml',
|
|
'.mir',
|
|
'.reek',
|
|
'.rviz',
|
|
'.sublime-syntax',
|
|
'.syntax',
|
|
'.yaml',
|
|
'.yaml-tmlanguage',
|
|
'.yaml.sed',
|
|
'.yml.mysql',
|
|
],
|
|
filenames: [
|
|
'.clang-format',
|
|
'.clang-tidy',
|
|
'.gemrc',
|
|
'CITATION.cff',
|
|
'glide.lock',
|
|
'.prettierrc',
|
|
'.stylelintrc',
|
|
'.lintstagedrc',
|
|
],
|
|
aceMode: 'yaml',
|
|
codemirrorMode: 'yaml',
|
|
codemirrorMimeType: 'text/x-yaml',
|
|
parsers: ['yaml'],
|
|
vscodeLanguageIds: [
|
|
'yaml',
|
|
'ansible',
|
|
'dockercompose',
|
|
'github-actions-workflow',
|
|
'home-assistant',
|
|
],
|
|
},
|
|
];
|
|
var Mt = {
|
|
bracketSpacing: {
|
|
category: 'Common',
|
|
type: 'boolean',
|
|
default: !0,
|
|
description: 'Print spaces between brackets.',
|
|
oppositeDescription: 'Do not print spaces between brackets.',
|
|
},
|
|
objectWrap: {
|
|
category: 'Common',
|
|
type: 'choice',
|
|
default: 'preserve',
|
|
description: 'How to wrap object literals.',
|
|
choices: [
|
|
{
|
|
value: 'preserve',
|
|
description:
|
|
'Keep as multi-line, if there is a newline between the opening brace and first property.',
|
|
},
|
|
{
|
|
value: 'collapse',
|
|
description: 'Fit to a single line when possible.',
|
|
},
|
|
],
|
|
},
|
|
singleQuote: {
|
|
category: 'Common',
|
|
type: 'boolean',
|
|
default: !1,
|
|
description: 'Use single quotes instead of double quotes.',
|
|
},
|
|
proseWrap: {
|
|
category: 'Common',
|
|
type: 'choice',
|
|
default: 'preserve',
|
|
description: 'How to wrap prose.',
|
|
choices: [
|
|
{
|
|
value: 'always',
|
|
description: 'Wrap prose if it exceeds the print width.',
|
|
},
|
|
{ value: 'never', description: 'Do not wrap prose.' },
|
|
{ value: 'preserve', description: 'Wrap prose as-is.' },
|
|
],
|
|
},
|
|
bracketSameLine: {
|
|
category: 'Common',
|
|
type: 'boolean',
|
|
default: !1,
|
|
description:
|
|
'Put > of opening tags on the last line instead of on a new line.',
|
|
},
|
|
singleAttributePerLine: {
|
|
category: 'Common',
|
|
type: 'boolean',
|
|
default: !1,
|
|
description: 'Enforce single attribute per line in HTML, Vue and JSX.',
|
|
},
|
|
};
|
|
var ao = {
|
|
bracketSpacing: Mt.bracketSpacing,
|
|
singleQuote: Mt.singleQuote,
|
|
proseWrap: Mt.proseWrap,
|
|
},
|
|
xr = ao;
|
|
var tr = {};
|
|
nr(tr, { yaml: () => Ga });
|
|
var kt = `
|
|
`,
|
|
Rr = '\r',
|
|
Dr = (function () {
|
|
function t(e) {
|
|
this.length = e.length;
|
|
for (var n = [0], r = 0; r < e.length; )
|
|
switch (e[r]) {
|
|
case kt:
|
|
(r += kt.length), n.push(r);
|
|
break;
|
|
case Rr:
|
|
(r += Rr.length), e[r] === kt && (r += kt.length), n.push(r);
|
|
break;
|
|
default:
|
|
r++;
|
|
break;
|
|
}
|
|
this.offsets = n;
|
|
}
|
|
return (
|
|
(t.prototype.locationForIndex = function (e) {
|
|
if (e < 0 || e > this.length) return null;
|
|
for (var n = 0, r = this.offsets; r[n + 1] <= e; ) n++;
|
|
var s = e - r[n];
|
|
return { line: n, column: s };
|
|
}),
|
|
(t.prototype.indexForLocation = function (e) {
|
|
var n = e.line,
|
|
r = e.column;
|
|
return (
|
|
n < 0 ||
|
|
n >= this.offsets.length ||
|
|
r < 0 ||
|
|
r > this.lengthOfLine(n)
|
|
) ?
|
|
null
|
|
: this.offsets[n] + r;
|
|
}),
|
|
(t.prototype.lengthOfLine = function (e) {
|
|
var n = this.offsets[e],
|
|
r =
|
|
e === this.offsets.length - 1 ? this.length : this.offsets[e + 1];
|
|
return r - n;
|
|
}),
|
|
t
|
|
);
|
|
})();
|
|
function $(t, e = null) {
|
|
'children' in t && t.children.forEach((n) => $(n, t)),
|
|
'anchor' in t && t.anchor && $(t.anchor, t),
|
|
'tag' in t && t.tag && $(t.tag, t),
|
|
'leadingComments' in t && t.leadingComments.forEach((n) => $(n, t)),
|
|
'middleComments' in t && t.middleComments.forEach((n) => $(n, t)),
|
|
'indicatorComment' in t && t.indicatorComment && $(t.indicatorComment, t),
|
|
'trailingComment' in t && t.trailingComment && $(t.trailingComment, t),
|
|
'endComments' in t && t.endComments.forEach((n) => $(n, t)),
|
|
Object.defineProperty(t, '_parent', { value: e, enumerable: !1 });
|
|
}
|
|
function de(t) {
|
|
return `${t.line}:${t.column}`;
|
|
}
|
|
function Yr(t) {
|
|
$(t);
|
|
let e = co(t),
|
|
n = t.children.slice();
|
|
t.comments
|
|
.sort((r, s) => r.position.start.offset - s.position.end.offset)
|
|
.filter((r) => !r._parent)
|
|
.forEach((r) => {
|
|
for (; n.length > 1 && r.position.start.line > n[0].position.end.line; )
|
|
n.shift();
|
|
lo(r, e, n[0]);
|
|
});
|
|
}
|
|
function co(t) {
|
|
let e = Array.from(new Array(t.position.end.line), () => ({}));
|
|
for (let n of t.comments) e[n.position.start.line - 1].comment = n;
|
|
return $r(e, t), e;
|
|
}
|
|
function $r(t, e) {
|
|
if (e.position.start.offset !== e.position.end.offset) {
|
|
if ('leadingComments' in e) {
|
|
let { start: n } = e.position,
|
|
{ leadingAttachableNode: r } = t[n.line - 1];
|
|
(!r || n.column < r.position.start.column) &&
|
|
(t[n.line - 1].leadingAttachableNode = e);
|
|
}
|
|
if (
|
|
'trailingComment' in e &&
|
|
e.position.end.column > 1 &&
|
|
e.type !== 'document' &&
|
|
e.type !== 'documentHead'
|
|
) {
|
|
let { end: n } = e.position,
|
|
{ trailingAttachableNode: r } = t[n.line - 1];
|
|
(!r || n.column >= r.position.end.column) &&
|
|
(t[n.line - 1].trailingAttachableNode = e);
|
|
}
|
|
if (
|
|
e.type !== 'root' &&
|
|
e.type !== 'document' &&
|
|
e.type !== 'documentHead' &&
|
|
e.type !== 'documentBody'
|
|
) {
|
|
let { start: n, end: r } = e.position,
|
|
s = [r.line].concat(n.line === r.line ? [] : n.line);
|
|
for (let i of s) {
|
|
let o = t[i - 1].trailingNode;
|
|
(!o || r.column >= o.position.end.column) &&
|
|
(t[i - 1].trailingNode = e);
|
|
}
|
|
}
|
|
'children' in e &&
|
|
e.children.forEach((n) => {
|
|
$r(t, n);
|
|
});
|
|
}
|
|
}
|
|
function lo(t, e, n) {
|
|
let r = t.position.start.line,
|
|
{ trailingAttachableNode: s } = e[r - 1];
|
|
if (s) {
|
|
if (s.trailingComment)
|
|
throw new Error(
|
|
`Unexpected multiple trailing comment at ${de(t.position.start)}`
|
|
);
|
|
$(t, s), (s.trailingComment = t);
|
|
return;
|
|
}
|
|
for (let o = r; o >= n.position.start.line; o--) {
|
|
let { trailingNode: a } = e[o - 1],
|
|
c;
|
|
if (a) c = a;
|
|
else if (o !== r && e[o - 1].comment) c = e[o - 1].comment._parent;
|
|
else continue;
|
|
if (
|
|
((c.type === 'sequence' || c.type === 'mapping') && (c = c.children[0]),
|
|
c.type === 'mappingItem')
|
|
) {
|
|
let [l, f] = c.children;
|
|
c = Br(l) ? l : f;
|
|
}
|
|
for (;;) {
|
|
if (fo(c, t)) {
|
|
$(t, c), c.endComments.push(t);
|
|
return;
|
|
}
|
|
if (!c._parent) break;
|
|
c = c._parent;
|
|
}
|
|
break;
|
|
}
|
|
for (let o = r + 1; o <= n.position.end.line; o++) {
|
|
let { leadingAttachableNode: a } = e[o - 1];
|
|
if (a) {
|
|
$(t, a), a.leadingComments.push(t);
|
|
return;
|
|
}
|
|
}
|
|
let i = n.children[1];
|
|
$(t, i), i.endComments.push(t);
|
|
}
|
|
function fo(t, e) {
|
|
if (
|
|
t.position.start.offset < e.position.start.offset &&
|
|
t.position.end.offset > e.position.end.offset
|
|
)
|
|
switch (t.type) {
|
|
case 'flowMapping':
|
|
case 'flowSequence':
|
|
return (
|
|
t.children.length === 0 ||
|
|
e.position.start.line >
|
|
t.children[t.children.length - 1].position.end.line
|
|
);
|
|
}
|
|
if (e.position.end.offset < t.position.end.offset) return !1;
|
|
switch (t.type) {
|
|
case 'sequenceItem':
|
|
return e.position.start.column > t.position.start.column;
|
|
case 'mappingKey':
|
|
case 'mappingValue':
|
|
return (
|
|
e.position.start.column > t._parent.position.start.column &&
|
|
(t.children.length === 0 ||
|
|
(t.children.length === 1 &&
|
|
t.children[0].type !== 'blockFolded' &&
|
|
t.children[0].type !== 'blockLiteral')) &&
|
|
(t.type === 'mappingValue' || Br(t))
|
|
);
|
|
default:
|
|
return !1;
|
|
}
|
|
}
|
|
function Br(t) {
|
|
return (
|
|
t.position.start !== t.position.end &&
|
|
(t.children.length === 0 ||
|
|
t.position.start.offset !== t.children[0].position.start.offset)
|
|
);
|
|
}
|
|
function b(t, e) {
|
|
return { type: t, position: e };
|
|
}
|
|
function Fr(t, e, n) {
|
|
return { ...b('root', t), children: e, comments: n };
|
|
}
|
|
function ct(t) {
|
|
switch (t.type) {
|
|
case 'DOCUMENT':
|
|
for (let e = t.contents.length - 1; e >= 0; e--)
|
|
t.contents[e].type === 'BLANK_LINE' ?
|
|
t.contents.splice(e, 1)
|
|
: ct(t.contents[e]);
|
|
for (let e = t.directives.length - 1; e >= 0; e--)
|
|
t.directives[e].type === 'BLANK_LINE' && t.directives.splice(e, 1);
|
|
break;
|
|
case 'FLOW_MAP':
|
|
case 'FLOW_SEQ':
|
|
case 'MAP':
|
|
case 'SEQ':
|
|
for (let e = t.items.length - 1; e >= 0; e--) {
|
|
let n = t.items[e];
|
|
'char' in n ||
|
|
(n.type === 'BLANK_LINE' ? t.items.splice(e, 1) : ct(n));
|
|
}
|
|
break;
|
|
case 'MAP_KEY':
|
|
case 'MAP_VALUE':
|
|
case 'SEQ_ITEM':
|
|
t.node && ct(t.node);
|
|
break;
|
|
case 'ALIAS':
|
|
case 'BLANK_LINE':
|
|
case 'BLOCK_FOLDED':
|
|
case 'BLOCK_LITERAL':
|
|
case 'COMMENT':
|
|
case 'DIRECTIVE':
|
|
case 'PLAIN':
|
|
case 'QUOTE_DOUBLE':
|
|
case 'QUOTE_SINGLE':
|
|
break;
|
|
default:
|
|
throw new Error(`Unexpected node type ${JSON.stringify(t.type)}`);
|
|
}
|
|
}
|
|
function X() {
|
|
return { leadingComments: [] };
|
|
}
|
|
function oe(t = null) {
|
|
return { trailingComment: t };
|
|
}
|
|
function B() {
|
|
return { ...X(), ...oe() };
|
|
}
|
|
function qr(t, e, n) {
|
|
return { ...b('alias', t), ...B(), ...e, value: n };
|
|
}
|
|
function Ur(t, e) {
|
|
let n = t.cstNode;
|
|
return qr(
|
|
e.transformRange({
|
|
origStart: n.valueRange.origStart - 1,
|
|
origEnd: n.valueRange.origEnd,
|
|
}),
|
|
e.transformContent(t),
|
|
n.rawValue
|
|
);
|
|
}
|
|
function Kr(t) {
|
|
return { ...t, type: 'blockFolded' };
|
|
}
|
|
function Vr(t, e, n, r, s, i) {
|
|
return {
|
|
...b('blockValue', t),
|
|
...X(),
|
|
...e,
|
|
chomping: n,
|
|
indent: r,
|
|
value: s,
|
|
indicatorComment: i,
|
|
};
|
|
}
|
|
var ae;
|
|
(function (t) {
|
|
(t.Tag = '!'), (t.Anchor = '&'), (t.Comment = '#');
|
|
})(ae || (ae = {}));
|
|
function Wr(t, e) {
|
|
return { ...b('anchor', t), value: e };
|
|
}
|
|
function De(t, e) {
|
|
return { ...b('comment', t), value: e };
|
|
}
|
|
function jr(t, e, n) {
|
|
return { anchor: e, tag: t, middleComments: n };
|
|
}
|
|
function Qr(t, e) {
|
|
return { ...b('tag', t), value: e };
|
|
}
|
|
function vt(t, e, n = () => !1) {
|
|
let r = t.cstNode,
|
|
s = [],
|
|
i = null,
|
|
o = null,
|
|
a = null;
|
|
for (let c of r.props) {
|
|
let l = e.text[c.origStart];
|
|
switch (l) {
|
|
case ae.Tag:
|
|
(i = i || c), (o = Qr(e.transformRange(c), t.tag));
|
|
break;
|
|
case ae.Anchor:
|
|
(i = i || c), (a = Wr(e.transformRange(c), r.anchor));
|
|
break;
|
|
case ae.Comment: {
|
|
let f = De(
|
|
e.transformRange(c),
|
|
e.text.slice(c.origStart + 1, c.origEnd)
|
|
);
|
|
e.comments.push(f),
|
|
!n(f) &&
|
|
i &&
|
|
i.origEnd <= c.origStart &&
|
|
c.origEnd <= r.valueRange.origStart &&
|
|
s.push(f);
|
|
break;
|
|
}
|
|
default:
|
|
throw new Error(`Unexpected leading character ${JSON.stringify(l)}`);
|
|
}
|
|
}
|
|
return jr(o, a, s);
|
|
}
|
|
var En;
|
|
(function (t) {
|
|
(t.CLIP = 'clip'), (t.STRIP = 'strip'), (t.KEEP = 'keep');
|
|
})(En || (En = {}));
|
|
function It(t, e) {
|
|
let n = t.cstNode,
|
|
r = 1,
|
|
s = n.chomping === 'CLIP' ? 0 : 1,
|
|
o = n.header.origEnd - n.header.origStart - r - s !== 0,
|
|
a = e.transformRange({
|
|
origStart: n.header.origStart,
|
|
origEnd: n.valueRange.origEnd,
|
|
}),
|
|
c = null,
|
|
l = vt(t, e, (f) => {
|
|
if (
|
|
!(
|
|
a.start.offset < f.position.start.offset &&
|
|
f.position.end.offset < a.end.offset
|
|
)
|
|
)
|
|
return !1;
|
|
if (c)
|
|
throw new Error(
|
|
`Unexpected multiple indicator comments at ${de(f.position.start)}`
|
|
);
|
|
return (c = f), !0;
|
|
});
|
|
return Vr(a, l, En[n.chomping], o ? n.blockIndent : null, n.strValue, c);
|
|
}
|
|
function Jr(t, e) {
|
|
return Kr(It(t, e));
|
|
}
|
|
function Gr(t) {
|
|
return { ...t, type: 'blockLiteral' };
|
|
}
|
|
function Hr(t, e) {
|
|
return Gr(It(t, e));
|
|
}
|
|
function Xr(t, e) {
|
|
return De(e.transformRange(t.range), t.comment);
|
|
}
|
|
function zr(t, e, n) {
|
|
return { ...b('directive', t), ...B(), name: e, parameters: n };
|
|
}
|
|
function Ye(t, e) {
|
|
for (let n of t.props) {
|
|
let r = e.text[n.origStart];
|
|
switch (r) {
|
|
case ae.Comment:
|
|
e.comments.push(
|
|
De(e.transformRange(n), e.text.slice(n.origStart + 1, n.origEnd))
|
|
);
|
|
break;
|
|
default:
|
|
throw new Error(`Unexpected leading character ${JSON.stringify(r)}`);
|
|
}
|
|
}
|
|
}
|
|
function Zr(t, e) {
|
|
return Ye(t, e), zr(e.transformRange(t.range), t.name, t.parameters);
|
|
}
|
|
function es(t, e, n, r) {
|
|
return { ...b('document', t), ...oe(r), children: [e, n] };
|
|
}
|
|
function V(t, e) {
|
|
return { start: t, end: e };
|
|
}
|
|
function Sn(t) {
|
|
return { start: t, end: t };
|
|
}
|
|
function F(t = []) {
|
|
return { endComments: t };
|
|
}
|
|
function ts(t, e, n) {
|
|
return { ...b('documentBody', t), ...F(n), children: e ? [e] : [] };
|
|
}
|
|
function q(t) {
|
|
return t[t.length - 1];
|
|
}
|
|
function Pt(t, e) {
|
|
let n = t.match(e);
|
|
return n ? n.index : -1;
|
|
}
|
|
function ns(t, e, n) {
|
|
let r = t.cstNode,
|
|
{
|
|
comments: s,
|
|
endComments: i,
|
|
documentTrailingComment: o,
|
|
documentHeadTrailingComment: a,
|
|
} = uo(r, e, n),
|
|
c = e.transformNode(t.contents),
|
|
{ position: l, documentEndPoint: f } = po(r, c, e);
|
|
return (
|
|
e.comments.push(...s, ...i),
|
|
{
|
|
documentBody: ts(l, c, i),
|
|
documentEndPoint: f,
|
|
documentTrailingComment: o,
|
|
documentHeadTrailingComment: a,
|
|
}
|
|
);
|
|
}
|
|
function uo(t, e, n) {
|
|
let r = [],
|
|
s = [],
|
|
i = [],
|
|
o = [],
|
|
a = !1;
|
|
for (let c = t.contents.length - 1; c >= 0; c--) {
|
|
let l = t.contents[c];
|
|
if (l.type === 'COMMENT') {
|
|
let f = e.transformNode(l);
|
|
n && n.line === f.position.start.line ? o.unshift(f)
|
|
: a ? r.unshift(f)
|
|
: f.position.start.offset >= t.valueRange.origEnd ? i.unshift(f)
|
|
: r.unshift(f);
|
|
} else a = !0;
|
|
}
|
|
if (i.length > 1)
|
|
throw new Error(
|
|
`Unexpected multiple document trailing comments at ${de(i[1].position.start)}`
|
|
);
|
|
if (o.length > 1)
|
|
throw new Error(
|
|
`Unexpected multiple documentHead trailing comments at ${de(o[1].position.start)}`
|
|
);
|
|
return {
|
|
comments: r,
|
|
endComments: s,
|
|
documentTrailingComment: q(i) || null,
|
|
documentHeadTrailingComment: q(o) || null,
|
|
};
|
|
}
|
|
function po(t, e, n) {
|
|
let r = Pt(n.text.slice(t.valueRange.origEnd), /^\.\.\./),
|
|
s =
|
|
r === -1 ? t.valueRange.origEnd : Math.max(0, t.valueRange.origEnd - 1);
|
|
n.text[s - 1] === '\r' && s--;
|
|
let i = n.transformRange({
|
|
origStart: e !== null ? e.position.start.offset : s,
|
|
origEnd: s,
|
|
}),
|
|
o = r === -1 ? i.end : n.transformOffset(t.valueRange.origEnd + 3);
|
|
return { position: i, documentEndPoint: o };
|
|
}
|
|
function rs(t, e, n, r) {
|
|
return { ...b('documentHead', t), ...F(n), ...oe(r), children: e };
|
|
}
|
|
function ss(t, e) {
|
|
let n = t.cstNode,
|
|
{ directives: r, comments: s, endComments: i } = mo(n, e),
|
|
{ position: o, endMarkerPoint: a } = ho(n, r, e);
|
|
return (
|
|
e.comments.push(...s, ...i),
|
|
{
|
|
createDocumentHeadWithTrailingComment: (l) => (
|
|
l && e.comments.push(l), rs(o, r, i, l)
|
|
),
|
|
documentHeadEndMarkerPoint: a,
|
|
}
|
|
);
|
|
}
|
|
function mo(t, e) {
|
|
let n = [],
|
|
r = [],
|
|
s = [],
|
|
i = !1;
|
|
for (let o = t.directives.length - 1; o >= 0; o--) {
|
|
let a = e.transformNode(t.directives[o]);
|
|
a.type === 'comment' ?
|
|
i ? r.unshift(a)
|
|
: s.unshift(a)
|
|
: ((i = !0), n.unshift(a));
|
|
}
|
|
return { directives: n, comments: r, endComments: s };
|
|
}
|
|
function ho(t, e, n) {
|
|
let r = Pt(n.text.slice(0, t.valueRange.origStart), /---\s*$/);
|
|
r > 0 && !/[\r\n]/.test(n.text[r - 1]) && (r = -1);
|
|
let s =
|
|
r === -1 ?
|
|
{ origStart: t.valueRange.origStart, origEnd: t.valueRange.origStart }
|
|
: { origStart: r, origEnd: r + 3 };
|
|
return (
|
|
e.length !== 0 && (s.origStart = e[0].position.start.offset),
|
|
{
|
|
position: n.transformRange(s),
|
|
endMarkerPoint: r === -1 ? null : n.transformOffset(r),
|
|
}
|
|
);
|
|
}
|
|
function is(t, e) {
|
|
let {
|
|
createDocumentHeadWithTrailingComment: n,
|
|
documentHeadEndMarkerPoint: r,
|
|
} = ss(t, e),
|
|
{
|
|
documentBody: s,
|
|
documentEndPoint: i,
|
|
documentTrailingComment: o,
|
|
documentHeadTrailingComment: a,
|
|
} = ns(t, e, r),
|
|
c = n(a);
|
|
return o && e.comments.push(o), es(V(c.position.start, i), c, s, o);
|
|
}
|
|
function _t(t, e, n) {
|
|
return { ...b('flowCollection', t), ...B(), ...F(), ...e, children: n };
|
|
}
|
|
function os(t, e, n) {
|
|
return { ..._t(t, e, n), type: 'flowMapping' };
|
|
}
|
|
function xt(t, e, n) {
|
|
return { ...b('flowMappingItem', t), ...X(), children: [e, n] };
|
|
}
|
|
function ce(t, e) {
|
|
let n = [];
|
|
for (let r of t)
|
|
r && 'type' in r && r.type === 'COMMENT' ?
|
|
e.comments.push(e.transformNode(r))
|
|
: n.push(r);
|
|
return n;
|
|
}
|
|
function Rt(t) {
|
|
let [e, n] = ['?', ':'].map((r) => {
|
|
let s = t.find((i) => 'char' in i && i.char === r);
|
|
return s ? { origStart: s.origOffset, origEnd: s.origOffset + 1 } : null;
|
|
});
|
|
return { additionalKeyRange: e, additionalValueRange: n };
|
|
}
|
|
function Dt(t, e) {
|
|
let n = e;
|
|
return (r) => t.slice(n, (n = r));
|
|
}
|
|
function Yt(t) {
|
|
let e = [],
|
|
n = Dt(t, 1),
|
|
r = !1;
|
|
for (let s = 1; s < t.length - 1; s++) {
|
|
let i = t[s];
|
|
if ('char' in i && i.char === ',') {
|
|
e.push(n(s)), n(s + 1), (r = !1);
|
|
continue;
|
|
}
|
|
r = !0;
|
|
}
|
|
return r && e.push(n(t.length - 1)), e;
|
|
}
|
|
function wn(t, e) {
|
|
return { ...b('mappingKey', t), ...oe(), ...F(), children: e ? [e] : [] };
|
|
}
|
|
function bn(t, e) {
|
|
return { ...b('mappingValue', t), ...B(), ...F(), children: e ? [e] : [] };
|
|
}
|
|
function $e(t, e, n, r, s) {
|
|
let i = e.transformNode(t.key),
|
|
o = e.transformNode(t.value),
|
|
a =
|
|
i || r ?
|
|
wn(
|
|
e.transformRange({
|
|
origStart: r ? r.origStart : i.position.start.offset,
|
|
origEnd: i ? i.position.end.offset : r.origStart + 1,
|
|
}),
|
|
i
|
|
)
|
|
: null,
|
|
c =
|
|
o || s ?
|
|
bn(
|
|
e.transformRange({
|
|
origStart: s ? s.origStart : o.position.start.offset,
|
|
origEnd: o ? o.position.end.offset : s.origStart + 1,
|
|
}),
|
|
o
|
|
)
|
|
: null;
|
|
return n(
|
|
V(
|
|
a ? a.position.start : c.position.start,
|
|
c ? c.position.end : a.position.end
|
|
),
|
|
a || wn(Sn(c.position.start), null),
|
|
c || bn(Sn(a.position.end), null)
|
|
);
|
|
}
|
|
function as(t, e) {
|
|
let n = ce(t.cstNode.items, e),
|
|
r = Yt(n),
|
|
s = t.items.map((a, c) => {
|
|
let l = r[c],
|
|
{ additionalKeyRange: f, additionalValueRange: m } = Rt(l);
|
|
return $e(a, e, xt, f, m);
|
|
}),
|
|
i = n[0],
|
|
o = q(n);
|
|
return os(
|
|
e.transformRange({ origStart: i.origOffset, origEnd: o.origOffset + 1 }),
|
|
e.transformContent(t),
|
|
s
|
|
);
|
|
}
|
|
function cs(t, e, n) {
|
|
return { ..._t(t, e, n), type: 'flowSequence' };
|
|
}
|
|
function ls(t, e) {
|
|
return { ...b('flowSequenceItem', t), children: [e] };
|
|
}
|
|
function fs(t, e) {
|
|
let n = ce(t.cstNode.items, e),
|
|
r = Yt(n),
|
|
s = t.items.map((a, c) => {
|
|
if (a.type !== 'PAIR') {
|
|
let l = e.transformNode(a);
|
|
return ls(V(l.position.start, l.position.end), l);
|
|
} else {
|
|
let l = r[c],
|
|
{ additionalKeyRange: f, additionalValueRange: m } = Rt(l);
|
|
return $e(a, e, xt, f, m);
|
|
}
|
|
}),
|
|
i = n[0],
|
|
o = q(n);
|
|
return cs(
|
|
e.transformRange({ origStart: i.origOffset, origEnd: o.origOffset + 1 }),
|
|
e.transformContent(t),
|
|
s
|
|
);
|
|
}
|
|
function us(t, e, n) {
|
|
return { ...b('mapping', t), ...X(), ...e, children: n };
|
|
}
|
|
function ps(t, e, n) {
|
|
return { ...b('mappingItem', t), ...X(), children: [e, n] };
|
|
}
|
|
function ms(t, e) {
|
|
let n = t.cstNode;
|
|
n.items
|
|
.filter((o) => o.type === 'MAP_KEY' || o.type === 'MAP_VALUE')
|
|
.forEach((o) => Ye(o, e));
|
|
let r = ce(n.items, e),
|
|
s = go(r),
|
|
i = t.items.map((o, a) => {
|
|
let c = s[a],
|
|
[l, f] =
|
|
c[0].type === 'MAP_VALUE' ?
|
|
[null, c[0].range]
|
|
: [c[0].range, c.length === 1 ? null : c[1].range];
|
|
return $e(o, e, ps, l, f);
|
|
});
|
|
return us(
|
|
V(i[0].position.start, q(i).position.end),
|
|
e.transformContent(t),
|
|
i
|
|
);
|
|
}
|
|
function go(t) {
|
|
let e = [],
|
|
n = Dt(t, 0),
|
|
r = !1;
|
|
for (let s = 0; s < t.length; s++) {
|
|
if (t[s].type === 'MAP_VALUE') {
|
|
e.push(n(s + 1)), (r = !1);
|
|
continue;
|
|
}
|
|
r && e.push(n(s)), (r = !0);
|
|
}
|
|
return r && e.push(n(1 / 0)), e;
|
|
}
|
|
function hs(t, e, n) {
|
|
return { ...b('plain', t), ...B(), ...e, value: n };
|
|
}
|
|
function gs(t, e, n) {
|
|
for (let r = e; r >= 0; r--) if (n.test(t[r])) return r;
|
|
return -1;
|
|
}
|
|
function ds(t, e) {
|
|
let n = t.cstNode;
|
|
return hs(
|
|
e.transformRange({
|
|
origStart: n.valueRange.origStart,
|
|
origEnd: gs(e.text, n.valueRange.origEnd - 1, /\S/) + 1,
|
|
}),
|
|
e.transformContent(t),
|
|
n.strValue
|
|
);
|
|
}
|
|
function ys(t) {
|
|
return { ...t, type: 'quoteDouble' };
|
|
}
|
|
function Es(t, e, n) {
|
|
return { ...b('quoteValue', t), ...e, ...B(), value: n };
|
|
}
|
|
function $t(t, e) {
|
|
let n = t.cstNode;
|
|
return Es(
|
|
e.transformRange(n.valueRange),
|
|
e.transformContent(t),
|
|
n.strValue
|
|
);
|
|
}
|
|
function Ss(t, e) {
|
|
return ys($t(t, e));
|
|
}
|
|
function ws(t) {
|
|
return { ...t, type: 'quoteSingle' };
|
|
}
|
|
function bs(t, e) {
|
|
return ws($t(t, e));
|
|
}
|
|
function Ns(t, e, n) {
|
|
return { ...b('sequence', t), ...X(), ...F(), ...e, children: n };
|
|
}
|
|
function Os(t, e) {
|
|
return { ...b('sequenceItem', t), ...B(), ...F(), children: e ? [e] : [] };
|
|
}
|
|
function Ls(t, e) {
|
|
let r = ce(t.cstNode.items, e).map((s, i) => {
|
|
Ye(s, e);
|
|
let o = e.transformNode(t.items[i]);
|
|
return Os(
|
|
V(
|
|
e.transformOffset(s.valueRange.origStart),
|
|
o === null ?
|
|
e.transformOffset(s.valueRange.origStart + 1)
|
|
: o.position.end
|
|
),
|
|
o
|
|
);
|
|
});
|
|
return Ns(
|
|
V(r[0].position.start, q(r).position.end),
|
|
e.transformContent(t),
|
|
r
|
|
);
|
|
}
|
|
function As(t, e) {
|
|
if (t === null || (t.type === void 0 && t.value === null)) return null;
|
|
switch (t.type) {
|
|
case 'ALIAS':
|
|
return Ur(t, e);
|
|
case 'BLOCK_FOLDED':
|
|
return Jr(t, e);
|
|
case 'BLOCK_LITERAL':
|
|
return Hr(t, e);
|
|
case 'COMMENT':
|
|
return Xr(t, e);
|
|
case 'DIRECTIVE':
|
|
return Zr(t, e);
|
|
case 'DOCUMENT':
|
|
return is(t, e);
|
|
case 'FLOW_MAP':
|
|
return as(t, e);
|
|
case 'FLOW_SEQ':
|
|
return fs(t, e);
|
|
case 'MAP':
|
|
return ms(t, e);
|
|
case 'PLAIN':
|
|
return ds(t, e);
|
|
case 'QUOTE_DOUBLE':
|
|
return Ss(t, e);
|
|
case 'QUOTE_SINGLE':
|
|
return bs(t, e);
|
|
case 'SEQ':
|
|
return Ls(t, e);
|
|
default:
|
|
throw new Error(`Unexpected node type ${t.type}`);
|
|
}
|
|
}
|
|
function Ts(t, e, n) {
|
|
let r = new SyntaxError(t);
|
|
return (r.name = 'YAMLSyntaxError'), (r.source = e), (r.position = n), r;
|
|
}
|
|
function Cs(t, e) {
|
|
let n = t.source.range || t.source.valueRange;
|
|
return Ts(t.message, e.text, e.transformRange(n));
|
|
}
|
|
function Ms(t, e, n) {
|
|
return { offset: t, line: e, column: n };
|
|
}
|
|
function ks(t, e) {
|
|
t < 0 ? (t = 0) : t > e.text.length && (t = e.text.length);
|
|
let n = e.locator.locationForIndex(t);
|
|
return Ms(t, n.line + 1, n.column + 1);
|
|
}
|
|
function vs(t, e) {
|
|
return V(e.transformOffset(t.origStart), e.transformOffset(t.origEnd));
|
|
}
|
|
function Is(t) {
|
|
if (!t.setOrigRanges()) {
|
|
let e = (n) => {
|
|
if (yo(n)) return (n.origStart = n.start), (n.origEnd = n.end), !0;
|
|
if (Eo(n)) return (n.origOffset = n.offset), !0;
|
|
};
|
|
t.forEach((n) => Nn(n, e));
|
|
}
|
|
}
|
|
function Nn(t, e) {
|
|
if (!(!t || typeof t != 'object') && e(t) !== !0)
|
|
for (let n of Object.keys(t)) {
|
|
if (n === 'context' || n === 'error') continue;
|
|
let r = t[n];
|
|
Array.isArray(r) ? r.forEach((s) => Nn(s, e)) : Nn(r, e);
|
|
}
|
|
}
|
|
function yo(t) {
|
|
return typeof t.start == 'number';
|
|
}
|
|
function Eo(t) {
|
|
return typeof t.offset == 'number';
|
|
}
|
|
function On(t) {
|
|
if ('children' in t) {
|
|
if (t.children.length === 1) {
|
|
let e = t.children[0];
|
|
if (
|
|
e.type === 'plain' &&
|
|
e.tag === null &&
|
|
e.anchor === null &&
|
|
e.value === ''
|
|
)
|
|
return t.children.splice(0, 1), t;
|
|
}
|
|
t.children.forEach(On);
|
|
}
|
|
return t;
|
|
}
|
|
function Ln(t, e, n, r) {
|
|
let s = e(t);
|
|
return (i) => {
|
|
r(s, i) && n(t, (s = i));
|
|
};
|
|
}
|
|
function An(t) {
|
|
if (t === null || !('children' in t)) return;
|
|
let e = t.children;
|
|
if ((e.forEach(An), t.type === 'document')) {
|
|
let [i, o] = t.children;
|
|
i.position.start.offset === i.position.end.offset ?
|
|
(i.position.start = i.position.end = o.position.start)
|
|
: o.position.start.offset === o.position.end.offset &&
|
|
(o.position.start = o.position.end = i.position.end);
|
|
}
|
|
let n = Ln(t.position, So, wo, Oo),
|
|
r = Ln(t.position, bo, No, Lo);
|
|
'endComments' in t &&
|
|
t.endComments.length !== 0 &&
|
|
(n(t.endComments[0].position.start), r(q(t.endComments).position.end));
|
|
let s = e.filter((i) => i !== null);
|
|
if (s.length !== 0) {
|
|
let i = s[0],
|
|
o = q(s);
|
|
n(i.position.start),
|
|
r(o.position.end),
|
|
'leadingComments' in i &&
|
|
i.leadingComments.length !== 0 &&
|
|
n(i.leadingComments[0].position.start),
|
|
'tag' in i && i.tag && n(i.tag.position.start),
|
|
'anchor' in i && i.anchor && n(i.anchor.position.start),
|
|
'trailingComment' in o &&
|
|
o.trailingComment &&
|
|
r(o.trailingComment.position.end);
|
|
}
|
|
}
|
|
function So(t) {
|
|
return t.start;
|
|
}
|
|
function wo(t, e) {
|
|
t.start = e;
|
|
}
|
|
function bo(t) {
|
|
return t.end;
|
|
}
|
|
function No(t, e) {
|
|
t.end = e;
|
|
}
|
|
function Oo(t, e) {
|
|
return e.offset < t.offset;
|
|
}
|
|
function Lo(t, e) {
|
|
return e.offset > t.offset;
|
|
}
|
|
var wi = sr(Ei(), 1);
|
|
var G = sr(Si(), 1),
|
|
Vm = G.default.findPair,
|
|
Wm = G.default.toJSON,
|
|
jm = G.default.parseMap,
|
|
Qm = G.default.parseSeq,
|
|
Jm = G.default.stringifyNumber,
|
|
Gm = G.default.stringifyString,
|
|
Hm = G.default.Type,
|
|
Va = G.default.YAMLError,
|
|
Xm = G.default.YAMLReferenceError,
|
|
er = G.default.YAMLSemanticError,
|
|
Wa = G.default.YAMLSyntaxError,
|
|
zm = G.default.YAMLWarning;
|
|
var { Document: bi, parseCST: Ni } = wi.default;
|
|
function Oi(t) {
|
|
let e = Ni(t);
|
|
Is(e);
|
|
let n = e.map((a) => new bi({ merge: !1, keepCstNodes: !0 }).parse(a)),
|
|
r = new Dr(t),
|
|
s = [],
|
|
i = {
|
|
text: t,
|
|
locator: r,
|
|
comments: s,
|
|
transformOffset: (a) => ks(a, i),
|
|
transformRange: (a) => vs(a, i),
|
|
transformNode: (a) => As(a, i),
|
|
transformContent: (a) => vt(a, i),
|
|
};
|
|
for (let a of n)
|
|
for (let c of a.errors)
|
|
if (
|
|
!(
|
|
c instanceof er &&
|
|
c.message === 'Map keys must be unique; "<<" is repeated'
|
|
)
|
|
)
|
|
throw Cs(c, i);
|
|
n.forEach((a) => ct(a.cstNode));
|
|
let o = Fr(
|
|
i.transformRange({ origStart: 0, origEnd: i.text.length }),
|
|
n.map(i.transformNode),
|
|
s
|
|
);
|
|
return Yr(o), An(o), On(o), o;
|
|
}
|
|
function Qa(t, e) {
|
|
let n = new SyntaxError(
|
|
t + ' (' + e.loc.start.line + ':' + e.loc.start.column + ')'
|
|
);
|
|
return Object.assign(n, e);
|
|
}
|
|
var Li = Qa;
|
|
function Ja(t) {
|
|
try {
|
|
let e = Oi(t);
|
|
return delete e.comments, e;
|
|
} catch (e) {
|
|
throw e != null && e.position ?
|
|
Li(e.message, { loc: e.position, cause: e })
|
|
: e;
|
|
}
|
|
}
|
|
var Ga = {
|
|
astFormat: 'yaml',
|
|
parse: Ja,
|
|
hasPragma: Sr,
|
|
locStart: Pe,
|
|
locEnd: yr,
|
|
};
|
|
var Ha = { yaml: Pr };
|
|
return Ii(Xa);
|
|
});
|