From b22040a8c6edd0a5b9a9abf95218b8797c5db7b4 Mon Sep 17 00:00:00 2001 From: David Anson Date: Wed, 3 Apr 2024 22:05:06 -0700 Subject: [PATCH] Freshen generated index.js file. --- dist/index.js | 14446 ++++++++++++++++++------------------------------ 1 file changed, 5424 insertions(+), 9022 deletions(-) diff --git a/dist/index.js b/dist/index.js index e8924cc..1c05e31 100644 --- a/dist/index.js +++ b/dist/index.js @@ -7529,6 +7529,4114 @@ module.exports = function(num) { }; +/***/ }), + +/***/ 1917: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + + +var loader = __nccwpck_require__(1161); +var dumper = __nccwpck_require__(8866); + + +function renamed(from, to) { + return function () { + throw new Error('Function yaml.' + from + ' is removed in js-yaml 4. ' + + 'Use yaml.' + to + ' instead, which is now safe by default.'); + }; +} + + +module.exports.Type = __nccwpck_require__(6073); +module.exports.Schema = __nccwpck_require__(1082); +module.exports.FAILSAFE_SCHEMA = __nccwpck_require__(8562); +module.exports.JSON_SCHEMA = __nccwpck_require__(1035); +module.exports.CORE_SCHEMA = __nccwpck_require__(2011); +module.exports.DEFAULT_SCHEMA = __nccwpck_require__(8759); +module.exports.load = loader.load; +module.exports.loadAll = loader.loadAll; +module.exports.dump = dumper.dump; +module.exports.YAMLException = __nccwpck_require__(8179); + +// Re-export all types in case user wants to create custom schema +module.exports.types = { + binary: __nccwpck_require__(7900), + float: __nccwpck_require__(2705), + map: __nccwpck_require__(6150), + null: __nccwpck_require__(721), + pairs: __nccwpck_require__(6860), + set: __nccwpck_require__(9548), + timestamp: __nccwpck_require__(9212), + bool: __nccwpck_require__(4993), + int: __nccwpck_require__(1615), + merge: __nccwpck_require__(6104), + omap: __nccwpck_require__(9046), + seq: __nccwpck_require__(7283), + str: __nccwpck_require__(3619) +}; + +// Removed functions from JS-YAML 3.0.x +module.exports.safeLoad = renamed('safeLoad', 'load'); +module.exports.safeLoadAll = renamed('safeLoadAll', 'loadAll'); +module.exports.safeDump = renamed('safeDump', 'dump'); + + +/***/ }), + +/***/ 6829: +/***/ ((module) => { + +"use strict"; + + + +function isNothing(subject) { + return (typeof subject === 'undefined') || (subject === null); +} + + +function isObject(subject) { + return (typeof subject === 'object') && (subject !== null); +} + + +function toArray(sequence) { + if (Array.isArray(sequence)) return sequence; + else if (isNothing(sequence)) return []; + + return [ sequence ]; +} + + +function extend(target, source) { + var index, length, key, sourceKeys; + + if (source) { + sourceKeys = Object.keys(source); + + for (index = 0, length = sourceKeys.length; index < length; index += 1) { + key = sourceKeys[index]; + target[key] = source[key]; + } + } + + return target; +} + + +function repeat(string, count) { + var result = '', cycle; + + for (cycle = 0; cycle < count; cycle += 1) { + result += string; + } + + return result; +} + + +function isNegativeZero(number) { + return (number === 0) && (Number.NEGATIVE_INFINITY === 1 / number); +} + + +module.exports.isNothing = isNothing; +module.exports.isObject = isObject; +module.exports.toArray = toArray; +module.exports.repeat = repeat; +module.exports.isNegativeZero = isNegativeZero; +module.exports.extend = extend; + + +/***/ }), + +/***/ 8866: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +/*eslint-disable no-use-before-define*/ + +var common = __nccwpck_require__(6829); +var YAMLException = __nccwpck_require__(8179); +var DEFAULT_SCHEMA = __nccwpck_require__(8759); + +var _toString = Object.prototype.toString; +var _hasOwnProperty = Object.prototype.hasOwnProperty; + +var CHAR_BOM = 0xFEFF; +var CHAR_TAB = 0x09; /* Tab */ +var CHAR_LINE_FEED = 0x0A; /* LF */ +var CHAR_CARRIAGE_RETURN = 0x0D; /* CR */ +var CHAR_SPACE = 0x20; /* Space */ +var CHAR_EXCLAMATION = 0x21; /* ! */ +var CHAR_DOUBLE_QUOTE = 0x22; /* " */ +var CHAR_SHARP = 0x23; /* # */ +var CHAR_PERCENT = 0x25; /* % */ +var CHAR_AMPERSAND = 0x26; /* & */ +var CHAR_SINGLE_QUOTE = 0x27; /* ' */ +var CHAR_ASTERISK = 0x2A; /* * */ +var CHAR_COMMA = 0x2C; /* , */ +var CHAR_MINUS = 0x2D; /* - */ +var CHAR_COLON = 0x3A; /* : */ +var CHAR_EQUALS = 0x3D; /* = */ +var CHAR_GREATER_THAN = 0x3E; /* > */ +var CHAR_QUESTION = 0x3F; /* ? */ +var CHAR_COMMERCIAL_AT = 0x40; /* @ */ +var CHAR_LEFT_SQUARE_BRACKET = 0x5B; /* [ */ +var CHAR_RIGHT_SQUARE_BRACKET = 0x5D; /* ] */ +var CHAR_GRAVE_ACCENT = 0x60; /* ` */ +var CHAR_LEFT_CURLY_BRACKET = 0x7B; /* { */ +var CHAR_VERTICAL_LINE = 0x7C; /* | */ +var CHAR_RIGHT_CURLY_BRACKET = 0x7D; /* } */ + +var ESCAPE_SEQUENCES = {}; + +ESCAPE_SEQUENCES[0x00] = '\\0'; +ESCAPE_SEQUENCES[0x07] = '\\a'; +ESCAPE_SEQUENCES[0x08] = '\\b'; +ESCAPE_SEQUENCES[0x09] = '\\t'; +ESCAPE_SEQUENCES[0x0A] = '\\n'; +ESCAPE_SEQUENCES[0x0B] = '\\v'; +ESCAPE_SEQUENCES[0x0C] = '\\f'; +ESCAPE_SEQUENCES[0x0D] = '\\r'; +ESCAPE_SEQUENCES[0x1B] = '\\e'; +ESCAPE_SEQUENCES[0x22] = '\\"'; +ESCAPE_SEQUENCES[0x5C] = '\\\\'; +ESCAPE_SEQUENCES[0x85] = '\\N'; +ESCAPE_SEQUENCES[0xA0] = '\\_'; +ESCAPE_SEQUENCES[0x2028] = '\\L'; +ESCAPE_SEQUENCES[0x2029] = '\\P'; + +var DEPRECATED_BOOLEANS_SYNTAX = [ + 'y', 'Y', 'yes', 'Yes', 'YES', 'on', 'On', 'ON', + 'n', 'N', 'no', 'No', 'NO', 'off', 'Off', 'OFF' +]; + +var DEPRECATED_BASE60_SYNTAX = /^[-+]?[0-9_]+(?::[0-9_]+)+(?:\.[0-9_]*)?$/; + +function compileStyleMap(schema, map) { + var result, keys, index, length, tag, style, type; + + if (map === null) return {}; + + result = {}; + keys = Object.keys(map); + + for (index = 0, length = keys.length; index < length; index += 1) { + tag = keys[index]; + style = String(map[tag]); + + if (tag.slice(0, 2) === '!!') { + tag = 'tag:yaml.org,2002:' + tag.slice(2); + } + type = schema.compiledTypeMap['fallback'][tag]; + + if (type && _hasOwnProperty.call(type.styleAliases, style)) { + style = type.styleAliases[style]; + } + + result[tag] = style; + } + + return result; +} + +function encodeHex(character) { + var string, handle, length; + + string = character.toString(16).toUpperCase(); + + if (character <= 0xFF) { + handle = 'x'; + length = 2; + } else if (character <= 0xFFFF) { + handle = 'u'; + length = 4; + } else if (character <= 0xFFFFFFFF) { + handle = 'U'; + length = 8; + } else { + throw new YAMLException('code point within a string may not be greater than 0xFFFFFFFF'); + } + + return '\\' + handle + common.repeat('0', length - string.length) + string; +} + + +var QUOTING_TYPE_SINGLE = 1, + QUOTING_TYPE_DOUBLE = 2; + +function State(options) { + this.schema = options['schema'] || DEFAULT_SCHEMA; + this.indent = Math.max(1, (options['indent'] || 2)); + this.noArrayIndent = options['noArrayIndent'] || false; + this.skipInvalid = options['skipInvalid'] || false; + this.flowLevel = (common.isNothing(options['flowLevel']) ? -1 : options['flowLevel']); + this.styleMap = compileStyleMap(this.schema, options['styles'] || null); + this.sortKeys = options['sortKeys'] || false; + this.lineWidth = options['lineWidth'] || 80; + this.noRefs = options['noRefs'] || false; + this.noCompatMode = options['noCompatMode'] || false; + this.condenseFlow = options['condenseFlow'] || false; + this.quotingType = options['quotingType'] === '"' ? QUOTING_TYPE_DOUBLE : QUOTING_TYPE_SINGLE; + this.forceQuotes = options['forceQuotes'] || false; + this.replacer = typeof options['replacer'] === 'function' ? options['replacer'] : null; + + this.implicitTypes = this.schema.compiledImplicit; + this.explicitTypes = this.schema.compiledExplicit; + + this.tag = null; + this.result = ''; + + this.duplicates = []; + this.usedDuplicates = null; +} + +// Indents every line in a string. Empty lines (\n only) are not indented. +function indentString(string, spaces) { + var ind = common.repeat(' ', spaces), + position = 0, + next = -1, + result = '', + line, + length = string.length; + + while (position < length) { + next = string.indexOf('\n', position); + if (next === -1) { + line = string.slice(position); + position = length; + } else { + line = string.slice(position, next + 1); + position = next + 1; + } + + if (line.length && line !== '\n') result += ind; + + result += line; + } + + return result; +} + +function generateNextLine(state, level) { + return '\n' + common.repeat(' ', state.indent * level); +} + +function testImplicitResolving(state, str) { + var index, length, type; + + for (index = 0, length = state.implicitTypes.length; index < length; index += 1) { + type = state.implicitTypes[index]; + + if (type.resolve(str)) { + return true; + } + } + + return false; +} + +// [33] s-white ::= s-space | s-tab +function isWhitespace(c) { + return c === CHAR_SPACE || c === CHAR_TAB; +} + +// Returns true if the character can be printed without escaping. +// From YAML 1.2: "any allowed characters known to be non-printable +// should also be escaped. [However,] This isn’t mandatory" +// Derived from nb-char - \t - #x85 - #xA0 - #x2028 - #x2029. +function isPrintable(c) { + return (0x00020 <= c && c <= 0x00007E) + || ((0x000A1 <= c && c <= 0x00D7FF) && c !== 0x2028 && c !== 0x2029) + || ((0x0E000 <= c && c <= 0x00FFFD) && c !== CHAR_BOM) + || (0x10000 <= c && c <= 0x10FFFF); +} + +// [34] ns-char ::= nb-char - s-white +// [27] nb-char ::= c-printable - b-char - c-byte-order-mark +// [26] b-char ::= b-line-feed | b-carriage-return +// Including s-white (for some reason, examples doesn't match specs in this aspect) +// ns-char ::= c-printable - b-line-feed - b-carriage-return - c-byte-order-mark +function isNsCharOrWhitespace(c) { + return isPrintable(c) + && c !== CHAR_BOM + // - b-char + && c !== CHAR_CARRIAGE_RETURN + && c !== CHAR_LINE_FEED; +} + +// [127] ns-plain-safe(c) ::= c = flow-out ⇒ ns-plain-safe-out +// c = flow-in ⇒ ns-plain-safe-in +// c = block-key ⇒ ns-plain-safe-out +// c = flow-key ⇒ ns-plain-safe-in +// [128] ns-plain-safe-out ::= ns-char +// [129] ns-plain-safe-in ::= ns-char - c-flow-indicator +// [130] ns-plain-char(c) ::= ( ns-plain-safe(c) - “:” - “#” ) +// | ( /* An ns-char preceding */ “#” ) +// | ( “:” /* Followed by an ns-plain-safe(c) */ ) +function isPlainSafe(c, prev, inblock) { + var cIsNsCharOrWhitespace = isNsCharOrWhitespace(c); + var cIsNsChar = cIsNsCharOrWhitespace && !isWhitespace(c); + return ( + // ns-plain-safe + inblock ? // c = flow-in + cIsNsCharOrWhitespace + : cIsNsCharOrWhitespace + // - c-flow-indicator + && c !== CHAR_COMMA + && c !== CHAR_LEFT_SQUARE_BRACKET + && c !== CHAR_RIGHT_SQUARE_BRACKET + && c !== CHAR_LEFT_CURLY_BRACKET + && c !== CHAR_RIGHT_CURLY_BRACKET + ) + // ns-plain-char + && c !== CHAR_SHARP // false on '#' + && !(prev === CHAR_COLON && !cIsNsChar) // false on ': ' + || (isNsCharOrWhitespace(prev) && !isWhitespace(prev) && c === CHAR_SHARP) // change to true on '[^ ]#' + || (prev === CHAR_COLON && cIsNsChar); // change to true on ':[^ ]' +} + +// Simplified test for values allowed as the first character in plain style. +function isPlainSafeFirst(c) { + // Uses a subset of ns-char - c-indicator + // where ns-char = nb-char - s-white. + // No support of ( ( “?” | “:” | “-” ) /* Followed by an ns-plain-safe(c)) */ ) part + return isPrintable(c) && c !== CHAR_BOM + && !isWhitespace(c) // - s-white + // - (c-indicator ::= + // “-” | “?” | “:” | “,” | “[” | “]” | “{” | “}” + && c !== CHAR_MINUS + && c !== CHAR_QUESTION + && c !== CHAR_COLON + && c !== CHAR_COMMA + && c !== CHAR_LEFT_SQUARE_BRACKET + && c !== CHAR_RIGHT_SQUARE_BRACKET + && c !== CHAR_LEFT_CURLY_BRACKET + && c !== CHAR_RIGHT_CURLY_BRACKET + // | “#” | “&” | “*” | “!” | “|” | “=” | “>” | “'” | “"” + && c !== CHAR_SHARP + && c !== CHAR_AMPERSAND + && c !== CHAR_ASTERISK + && c !== CHAR_EXCLAMATION + && c !== CHAR_VERTICAL_LINE + && c !== CHAR_EQUALS + && c !== CHAR_GREATER_THAN + && c !== CHAR_SINGLE_QUOTE + && c !== CHAR_DOUBLE_QUOTE + // | “%” | “@” | “`”) + && c !== CHAR_PERCENT + && c !== CHAR_COMMERCIAL_AT + && c !== CHAR_GRAVE_ACCENT; +} + +// Simplified test for values allowed as the last character in plain style. +function isPlainSafeLast(c) { + // just not whitespace or colon, it will be checked to be plain character later + return !isWhitespace(c) && c !== CHAR_COLON; +} + +// Same as 'string'.codePointAt(pos), but works in older browsers. +function codePointAt(string, pos) { + var first = string.charCodeAt(pos), second; + if (first >= 0xD800 && first <= 0xDBFF && pos + 1 < string.length) { + second = string.charCodeAt(pos + 1); + if (second >= 0xDC00 && second <= 0xDFFF) { + // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae + return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000; + } + } + return first; +} + +// Determines whether block indentation indicator is required. +function needIndentIndicator(string) { + var leadingSpaceRe = /^\n* /; + return leadingSpaceRe.test(string); +} + +var STYLE_PLAIN = 1, + STYLE_SINGLE = 2, + STYLE_LITERAL = 3, + STYLE_FOLDED = 4, + STYLE_DOUBLE = 5; + +// Determines which scalar styles are possible and returns the preferred style. +// lineWidth = -1 => no limit. +// Pre-conditions: str.length > 0. +// Post-conditions: +// STYLE_PLAIN or STYLE_SINGLE => no \n are in the string. +// STYLE_LITERAL => no lines are suitable for folding (or lineWidth is -1). +// STYLE_FOLDED => a line > lineWidth and can be folded (and lineWidth != -1). +function chooseScalarStyle(string, singleLineOnly, indentPerLevel, lineWidth, + testAmbiguousType, quotingType, forceQuotes, inblock) { + + var i; + var char = 0; + var prevChar = null; + var hasLineBreak = false; + var hasFoldableLine = false; // only checked if shouldTrackWidth + var shouldTrackWidth = lineWidth !== -1; + var previousLineBreak = -1; // count the first line correctly + var plain = isPlainSafeFirst(codePointAt(string, 0)) + && isPlainSafeLast(codePointAt(string, string.length - 1)); + + if (singleLineOnly || forceQuotes) { + // Case: no block styles. + // Check for disallowed characters to rule out plain and single. + for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) { + char = codePointAt(string, i); + if (!isPrintable(char)) { + return STYLE_DOUBLE; + } + plain = plain && isPlainSafe(char, prevChar, inblock); + prevChar = char; + } + } else { + // Case: block styles permitted. + for (i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) { + char = codePointAt(string, i); + if (char === CHAR_LINE_FEED) { + hasLineBreak = true; + // Check if any line can be folded. + if (shouldTrackWidth) { + hasFoldableLine = hasFoldableLine || + // Foldable line = too long, and not more-indented. + (i - previousLineBreak - 1 > lineWidth && + string[previousLineBreak + 1] !== ' '); + previousLineBreak = i; + } + } else if (!isPrintable(char)) { + return STYLE_DOUBLE; + } + plain = plain && isPlainSafe(char, prevChar, inblock); + prevChar = char; + } + // in case the end is missing a \n + hasFoldableLine = hasFoldableLine || (shouldTrackWidth && + (i - previousLineBreak - 1 > lineWidth && + string[previousLineBreak + 1] !== ' ')); + } + // Although every style can represent \n without escaping, prefer block styles + // for multiline, since they're more readable and they don't add empty lines. + // Also prefer folding a super-long line. + if (!hasLineBreak && !hasFoldableLine) { + // Strings interpretable as another type have to be quoted; + // e.g. the string 'true' vs. the boolean true. + if (plain && !forceQuotes && !testAmbiguousType(string)) { + return STYLE_PLAIN; + } + return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE; + } + // Edge case: block indentation indicator can only have one digit. + if (indentPerLevel > 9 && needIndentIndicator(string)) { + return STYLE_DOUBLE; + } + // At this point we know block styles are valid. + // Prefer literal style unless we want to fold. + if (!forceQuotes) { + return hasFoldableLine ? STYLE_FOLDED : STYLE_LITERAL; + } + return quotingType === QUOTING_TYPE_DOUBLE ? STYLE_DOUBLE : STYLE_SINGLE; +} + +// Note: line breaking/folding is implemented for only the folded style. +// NB. We drop the last trailing newline (if any) of a returned block scalar +// since the dumper adds its own newline. This always works: +// • No ending newline => unaffected; already using strip "-" chomping. +// • Ending newline => removed then restored. +// Importantly, this keeps the "+" chomp indicator from gaining an extra line. +function writeScalar(state, string, level, iskey, inblock) { + state.dump = (function () { + if (string.length === 0) { + return state.quotingType === QUOTING_TYPE_DOUBLE ? '""' : "''"; + } + if (!state.noCompatMode) { + if (DEPRECATED_BOOLEANS_SYNTAX.indexOf(string) !== -1 || DEPRECATED_BASE60_SYNTAX.test(string)) { + return state.quotingType === QUOTING_TYPE_DOUBLE ? ('"' + string + '"') : ("'" + string + "'"); + } + } + + var indent = state.indent * Math.max(1, level); // no 0-indent scalars + // As indentation gets deeper, let the width decrease monotonically + // to the lower bound min(state.lineWidth, 40). + // Note that this implies + // state.lineWidth ≤ 40 + state.indent: width is fixed at the lower bound. + // state.lineWidth > 40 + state.indent: width decreases until the lower bound. + // This behaves better than a constant minimum width which disallows narrower options, + // or an indent threshold which causes the width to suddenly increase. + var lineWidth = state.lineWidth === -1 + ? -1 : Math.max(Math.min(state.lineWidth, 40), state.lineWidth - indent); + + // Without knowing if keys are implicit/explicit, assume implicit for safety. + var singleLineOnly = iskey + // No block styles in flow mode. + || (state.flowLevel > -1 && level >= state.flowLevel); + function testAmbiguity(string) { + return testImplicitResolving(state, string); + } + + switch (chooseScalarStyle(string, singleLineOnly, state.indent, lineWidth, + testAmbiguity, state.quotingType, state.forceQuotes && !iskey, inblock)) { + + case STYLE_PLAIN: + return string; + case STYLE_SINGLE: + return "'" + string.replace(/'/g, "''") + "'"; + case STYLE_LITERAL: + return '|' + blockHeader(string, state.indent) + + dropEndingNewline(indentString(string, indent)); + case STYLE_FOLDED: + return '>' + blockHeader(string, state.indent) + + dropEndingNewline(indentString(foldString(string, lineWidth), indent)); + case STYLE_DOUBLE: + return '"' + escapeString(string, lineWidth) + '"'; + default: + throw new YAMLException('impossible error: invalid scalar style'); + } + }()); +} + +// Pre-conditions: string is valid for a block scalar, 1 <= indentPerLevel <= 9. +function blockHeader(string, indentPerLevel) { + var indentIndicator = needIndentIndicator(string) ? String(indentPerLevel) : ''; + + // note the special case: the string '\n' counts as a "trailing" empty line. + var clip = string[string.length - 1] === '\n'; + var keep = clip && (string[string.length - 2] === '\n' || string === '\n'); + var chomp = keep ? '+' : (clip ? '' : '-'); + + return indentIndicator + chomp + '\n'; +} + +// (See the note for writeScalar.) +function dropEndingNewline(string) { + return string[string.length - 1] === '\n' ? string.slice(0, -1) : string; +} + +// Note: a long line without a suitable break point will exceed the width limit. +// Pre-conditions: every char in str isPrintable, str.length > 0, width > 0. +function foldString(string, width) { + // In folded style, $k$ consecutive newlines output as $k+1$ newlines— + // unless they're before or after a more-indented line, or at the very + // beginning or end, in which case $k$ maps to $k$. + // Therefore, parse each chunk as newline(s) followed by a content line. + var lineRe = /(\n+)([^\n]*)/g; + + // first line (possibly an empty line) + var result = (function () { + var nextLF = string.indexOf('\n'); + nextLF = nextLF !== -1 ? nextLF : string.length; + lineRe.lastIndex = nextLF; + return foldLine(string.slice(0, nextLF), width); + }()); + // If we haven't reached the first content line yet, don't add an extra \n. + var prevMoreIndented = string[0] === '\n' || string[0] === ' '; + var moreIndented; + + // rest of the lines + var match; + while ((match = lineRe.exec(string))) { + var prefix = match[1], line = match[2]; + moreIndented = (line[0] === ' '); + result += prefix + + (!prevMoreIndented && !moreIndented && line !== '' + ? '\n' : '') + + foldLine(line, width); + prevMoreIndented = moreIndented; + } + + return result; +} + +// Greedy line breaking. +// Picks the longest line under the limit each time, +// otherwise settles for the shortest line over the limit. +// NB. More-indented lines *cannot* be folded, as that would add an extra \n. +function foldLine(line, width) { + if (line === '' || line[0] === ' ') return line; + + // Since a more-indented line adds a \n, breaks can't be followed by a space. + var breakRe = / [^ ]/g; // note: the match index will always be <= length-2. + var match; + // start is an inclusive index. end, curr, and next are exclusive. + var start = 0, end, curr = 0, next = 0; + var result = ''; + + // Invariants: 0 <= start <= length-1. + // 0 <= curr <= next <= max(0, length-2). curr - start <= width. + // Inside the loop: + // A match implies length >= 2, so curr and next are <= length-2. + while ((match = breakRe.exec(line))) { + next = match.index; + // maintain invariant: curr - start <= width + if (next - start > width) { + end = (curr > start) ? curr : next; // derive end <= length-2 + result += '\n' + line.slice(start, end); + // skip the space that was output as \n + start = end + 1; // derive start <= length-1 + } + curr = next; + } + + // By the invariants, start <= length-1, so there is something left over. + // It is either the whole string or a part starting from non-whitespace. + result += '\n'; + // Insert a break if the remainder is too long and there is a break available. + if (line.length - start > width && curr > start) { + result += line.slice(start, curr) + '\n' + line.slice(curr + 1); + } else { + result += line.slice(start); + } + + return result.slice(1); // drop extra \n joiner +} + +// Escapes a double-quoted string. +function escapeString(string) { + var result = ''; + var char = 0; + var escapeSeq; + + for (var i = 0; i < string.length; char >= 0x10000 ? i += 2 : i++) { + char = codePointAt(string, i); + escapeSeq = ESCAPE_SEQUENCES[char]; + + if (!escapeSeq && isPrintable(char)) { + result += string[i]; + if (char >= 0x10000) result += string[i + 1]; + } else { + result += escapeSeq || encodeHex(char); + } + } + + return result; +} + +function writeFlowSequence(state, level, object) { + var _result = '', + _tag = state.tag, + index, + length, + value; + + for (index = 0, length = object.length; index < length; index += 1) { + value = object[index]; + + if (state.replacer) { + value = state.replacer.call(object, String(index), value); + } + + // Write only valid elements, put null instead of invalid elements. + if (writeNode(state, level, value, false, false) || + (typeof value === 'undefined' && + writeNode(state, level, null, false, false))) { + + if (_result !== '') _result += ',' + (!state.condenseFlow ? ' ' : ''); + _result += state.dump; + } + } + + state.tag = _tag; + state.dump = '[' + _result + ']'; +} + +function writeBlockSequence(state, level, object, compact) { + var _result = '', + _tag = state.tag, + index, + length, + value; + + for (index = 0, length = object.length; index < length; index += 1) { + value = object[index]; + + if (state.replacer) { + value = state.replacer.call(object, String(index), value); + } + + // Write only valid elements, put null instead of invalid elements. + if (writeNode(state, level + 1, value, true, true, false, true) || + (typeof value === 'undefined' && + writeNode(state, level + 1, null, true, true, false, true))) { + + if (!compact || _result !== '') { + _result += generateNextLine(state, level); + } + + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + _result += '-'; + } else { + _result += '- '; + } + + _result += state.dump; + } + } + + state.tag = _tag; + state.dump = _result || '[]'; // Empty sequence if no valid values. +} + +function writeFlowMapping(state, level, object) { + var _result = '', + _tag = state.tag, + objectKeyList = Object.keys(object), + index, + length, + objectKey, + objectValue, + pairBuffer; + + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + + pairBuffer = ''; + if (_result !== '') pairBuffer += ', '; + + if (state.condenseFlow) pairBuffer += '"'; + + objectKey = objectKeyList[index]; + objectValue = object[objectKey]; + + if (state.replacer) { + objectValue = state.replacer.call(object, objectKey, objectValue); + } + + if (!writeNode(state, level, objectKey, false, false)) { + continue; // Skip this pair because of invalid key; + } + + if (state.dump.length > 1024) pairBuffer += '? '; + + pairBuffer += state.dump + (state.condenseFlow ? '"' : '') + ':' + (state.condenseFlow ? '' : ' '); + + if (!writeNode(state, level, objectValue, false, false)) { + continue; // Skip this pair because of invalid value. + } + + pairBuffer += state.dump; + + // Both key and value are valid. + _result += pairBuffer; + } + + state.tag = _tag; + state.dump = '{' + _result + '}'; +} + +function writeBlockMapping(state, level, object, compact) { + var _result = '', + _tag = state.tag, + objectKeyList = Object.keys(object), + index, + length, + objectKey, + objectValue, + explicitPair, + pairBuffer; + + // Allow sorting keys so that the output file is deterministic + if (state.sortKeys === true) { + // Default sorting + objectKeyList.sort(); + } else if (typeof state.sortKeys === 'function') { + // Custom sort function + objectKeyList.sort(state.sortKeys); + } else if (state.sortKeys) { + // Something is wrong + throw new YAMLException('sortKeys must be a boolean or a function'); + } + + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + pairBuffer = ''; + + if (!compact || _result !== '') { + pairBuffer += generateNextLine(state, level); + } + + objectKey = objectKeyList[index]; + objectValue = object[objectKey]; + + if (state.replacer) { + objectValue = state.replacer.call(object, objectKey, objectValue); + } + + if (!writeNode(state, level + 1, objectKey, true, true, true)) { + continue; // Skip this pair because of invalid key. + } + + explicitPair = (state.tag !== null && state.tag !== '?') || + (state.dump && state.dump.length > 1024); + + if (explicitPair) { + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + pairBuffer += '?'; + } else { + pairBuffer += '? '; + } + } + + pairBuffer += state.dump; + + if (explicitPair) { + pairBuffer += generateNextLine(state, level); + } + + if (!writeNode(state, level + 1, objectValue, true, explicitPair)) { + continue; // Skip this pair because of invalid value. + } + + if (state.dump && CHAR_LINE_FEED === state.dump.charCodeAt(0)) { + pairBuffer += ':'; + } else { + pairBuffer += ': '; + } + + pairBuffer += state.dump; + + // Both key and value are valid. + _result += pairBuffer; + } + + state.tag = _tag; + state.dump = _result || '{}'; // Empty mapping if no valid pairs. +} + +function detectType(state, object, explicit) { + var _result, typeList, index, length, type, style; + + typeList = explicit ? state.explicitTypes : state.implicitTypes; + + for (index = 0, length = typeList.length; index < length; index += 1) { + type = typeList[index]; + + if ((type.instanceOf || type.predicate) && + (!type.instanceOf || ((typeof object === 'object') && (object instanceof type.instanceOf))) && + (!type.predicate || type.predicate(object))) { + + if (explicit) { + if (type.multi && type.representName) { + state.tag = type.representName(object); + } else { + state.tag = type.tag; + } + } else { + state.tag = '?'; + } + + if (type.represent) { + style = state.styleMap[type.tag] || type.defaultStyle; + + if (_toString.call(type.represent) === '[object Function]') { + _result = type.represent(object, style); + } else if (_hasOwnProperty.call(type.represent, style)) { + _result = type.represent[style](object, style); + } else { + throw new YAMLException('!<' + type.tag + '> tag resolver accepts not "' + style + '" style'); + } + + state.dump = _result; + } + + return true; + } + } + + return false; +} + +// Serializes `object` and writes it to global `result`. +// Returns true on success, or false on invalid object. +// +function writeNode(state, level, object, block, compact, iskey, isblockseq) { + state.tag = null; + state.dump = object; + + if (!detectType(state, object, false)) { + detectType(state, object, true); + } + + var type = _toString.call(state.dump); + var inblock = block; + var tagStr; + + if (block) { + block = (state.flowLevel < 0 || state.flowLevel > level); + } + + var objectOrArray = type === '[object Object]' || type === '[object Array]', + duplicateIndex, + duplicate; + + if (objectOrArray) { + duplicateIndex = state.duplicates.indexOf(object); + duplicate = duplicateIndex !== -1; + } + + if ((state.tag !== null && state.tag !== '?') || duplicate || (state.indent !== 2 && level > 0)) { + compact = false; + } + + if (duplicate && state.usedDuplicates[duplicateIndex]) { + state.dump = '*ref_' + duplicateIndex; + } else { + if (objectOrArray && duplicate && !state.usedDuplicates[duplicateIndex]) { + state.usedDuplicates[duplicateIndex] = true; + } + if (type === '[object Object]') { + if (block && (Object.keys(state.dump).length !== 0)) { + writeBlockMapping(state, level, state.dump, compact); + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + state.dump; + } + } else { + writeFlowMapping(state, level, state.dump); + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + ' ' + state.dump; + } + } + } else if (type === '[object Array]') { + if (block && (state.dump.length !== 0)) { + if (state.noArrayIndent && !isblockseq && level > 0) { + writeBlockSequence(state, level - 1, state.dump, compact); + } else { + writeBlockSequence(state, level, state.dump, compact); + } + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + state.dump; + } + } else { + writeFlowSequence(state, level, state.dump); + if (duplicate) { + state.dump = '&ref_' + duplicateIndex + ' ' + state.dump; + } + } + } else if (type === '[object String]') { + if (state.tag !== '?') { + writeScalar(state, state.dump, level, iskey, inblock); + } + } else if (type === '[object Undefined]') { + return false; + } else { + if (state.skipInvalid) return false; + throw new YAMLException('unacceptable kind of an object to dump ' + type); + } + + if (state.tag !== null && state.tag !== '?') { + // Need to encode all characters except those allowed by the spec: + // + // [35] ns-dec-digit ::= [#x30-#x39] /* 0-9 */ + // [36] ns-hex-digit ::= ns-dec-digit + // | [#x41-#x46] /* A-F */ | [#x61-#x66] /* a-f */ + // [37] ns-ascii-letter ::= [#x41-#x5A] /* A-Z */ | [#x61-#x7A] /* a-z */ + // [38] ns-word-char ::= ns-dec-digit | ns-ascii-letter | “-” + // [39] ns-uri-char ::= “%” ns-hex-digit ns-hex-digit | ns-word-char | “#” + // | “;” | “/” | “?” | “:” | “@” | “&” | “=” | “+” | “$” | “,” + // | “_” | “.” | “!” | “~” | “*” | “'” | “(” | “)” | “[” | “]” + // + // Also need to encode '!' because it has special meaning (end of tag prefix). + // + tagStr = encodeURI( + state.tag[0] === '!' ? state.tag.slice(1) : state.tag + ).replace(/!/g, '%21'); + + if (state.tag[0] === '!') { + tagStr = '!' + tagStr; + } else if (tagStr.slice(0, 18) === 'tag:yaml.org,2002:') { + tagStr = '!!' + tagStr.slice(18); + } else { + tagStr = '!<' + tagStr + '>'; + } + + state.dump = tagStr + ' ' + state.dump; + } + } + + return true; +} + +function getDuplicateReferences(object, state) { + var objects = [], + duplicatesIndexes = [], + index, + length; + + inspectNode(object, objects, duplicatesIndexes); + + for (index = 0, length = duplicatesIndexes.length; index < length; index += 1) { + state.duplicates.push(objects[duplicatesIndexes[index]]); + } + state.usedDuplicates = new Array(length); +} + +function inspectNode(object, objects, duplicatesIndexes) { + var objectKeyList, + index, + length; + + if (object !== null && typeof object === 'object') { + index = objects.indexOf(object); + if (index !== -1) { + if (duplicatesIndexes.indexOf(index) === -1) { + duplicatesIndexes.push(index); + } + } else { + objects.push(object); + + if (Array.isArray(object)) { + for (index = 0, length = object.length; index < length; index += 1) { + inspectNode(object[index], objects, duplicatesIndexes); + } + } else { + objectKeyList = Object.keys(object); + + for (index = 0, length = objectKeyList.length; index < length; index += 1) { + inspectNode(object[objectKeyList[index]], objects, duplicatesIndexes); + } + } + } + } +} + +function dump(input, options) { + options = options || {}; + + var state = new State(options); + + if (!state.noRefs) getDuplicateReferences(input, state); + + var value = input; + + if (state.replacer) { + value = state.replacer.call({ '': value }, '', value); + } + + if (writeNode(state, 0, value, true, true)) return state.dump + '\n'; + + return ''; +} + +module.exports.dump = dump; + + +/***/ }), + +/***/ 8179: +/***/ ((module) => { + +"use strict"; +// YAML error class. http://stackoverflow.com/questions/8458984 +// + + + +function formatError(exception, compact) { + var where = '', message = exception.reason || '(unknown reason)'; + + if (!exception.mark) return message; + + if (exception.mark.name) { + where += 'in "' + exception.mark.name + '" '; + } + + where += '(' + (exception.mark.line + 1) + ':' + (exception.mark.column + 1) + ')'; + + if (!compact && exception.mark.snippet) { + where += '\n\n' + exception.mark.snippet; + } + + return message + ' ' + where; +} + + +function YAMLException(reason, mark) { + // Super constructor + Error.call(this); + + this.name = 'YAMLException'; + this.reason = reason; + this.mark = mark; + this.message = formatError(this, false); + + // Include stack trace in error object + if (Error.captureStackTrace) { + // Chrome and NodeJS + Error.captureStackTrace(this, this.constructor); + } else { + // FF, IE 10+ and Safari 6+. Fallback for others + this.stack = (new Error()).stack || ''; + } +} + + +// Inherit from Error +YAMLException.prototype = Object.create(Error.prototype); +YAMLException.prototype.constructor = YAMLException; + + +YAMLException.prototype.toString = function toString(compact) { + return this.name + ': ' + formatError(this, compact); +}; + + +module.exports = YAMLException; + + +/***/ }), + +/***/ 1161: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +/*eslint-disable max-len,no-use-before-define*/ + +var common = __nccwpck_require__(6829); +var YAMLException = __nccwpck_require__(8179); +var makeSnippet = __nccwpck_require__(6975); +var DEFAULT_SCHEMA = __nccwpck_require__(8759); + + +var _hasOwnProperty = Object.prototype.hasOwnProperty; + + +var CONTEXT_FLOW_IN = 1; +var CONTEXT_FLOW_OUT = 2; +var CONTEXT_BLOCK_IN = 3; +var CONTEXT_BLOCK_OUT = 4; + + +var CHOMPING_CLIP = 1; +var CHOMPING_STRIP = 2; +var CHOMPING_KEEP = 3; + + +var PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/; +var PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/; +var PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/; +var PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i; +var PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i; + + +function _class(obj) { return Object.prototype.toString.call(obj); } + +function is_EOL(c) { + return (c === 0x0A/* LF */) || (c === 0x0D/* CR */); +} + +function is_WHITE_SPACE(c) { + return (c === 0x09/* Tab */) || (c === 0x20/* Space */); +} + +function is_WS_OR_EOL(c) { + return (c === 0x09/* Tab */) || + (c === 0x20/* Space */) || + (c === 0x0A/* LF */) || + (c === 0x0D/* CR */); +} + +function is_FLOW_INDICATOR(c) { + return c === 0x2C/* , */ || + c === 0x5B/* [ */ || + c === 0x5D/* ] */ || + c === 0x7B/* { */ || + c === 0x7D/* } */; +} + +function fromHexCode(c) { + var lc; + + if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) { + return c - 0x30; + } + + /*eslint-disable no-bitwise*/ + lc = c | 0x20; + + if ((0x61/* a */ <= lc) && (lc <= 0x66/* f */)) { + return lc - 0x61 + 10; + } + + return -1; +} + +function escapedHexLen(c) { + if (c === 0x78/* x */) { return 2; } + if (c === 0x75/* u */) { return 4; } + if (c === 0x55/* U */) { return 8; } + return 0; +} + +function fromDecimalCode(c) { + if ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) { + return c - 0x30; + } + + return -1; +} + +function simpleEscapeSequence(c) { + /* eslint-disable indent */ + return (c === 0x30/* 0 */) ? '\x00' : + (c === 0x61/* a */) ? '\x07' : + (c === 0x62/* b */) ? '\x08' : + (c === 0x74/* t */) ? '\x09' : + (c === 0x09/* Tab */) ? '\x09' : + (c === 0x6E/* n */) ? '\x0A' : + (c === 0x76/* v */) ? '\x0B' : + (c === 0x66/* f */) ? '\x0C' : + (c === 0x72/* r */) ? '\x0D' : + (c === 0x65/* e */) ? '\x1B' : + (c === 0x20/* Space */) ? ' ' : + (c === 0x22/* " */) ? '\x22' : + (c === 0x2F/* / */) ? '/' : + (c === 0x5C/* \ */) ? '\x5C' : + (c === 0x4E/* N */) ? '\x85' : + (c === 0x5F/* _ */) ? '\xA0' : + (c === 0x4C/* L */) ? '\u2028' : + (c === 0x50/* P */) ? '\u2029' : ''; +} + +function charFromCodepoint(c) { + if (c <= 0xFFFF) { + return String.fromCharCode(c); + } + // Encode UTF-16 surrogate pair + // https://en.wikipedia.org/wiki/UTF-16#Code_points_U.2B010000_to_U.2B10FFFF + return String.fromCharCode( + ((c - 0x010000) >> 10) + 0xD800, + ((c - 0x010000) & 0x03FF) + 0xDC00 + ); +} + +var simpleEscapeCheck = new Array(256); // integer, for fast access +var simpleEscapeMap = new Array(256); +for (var i = 0; i < 256; i++) { + simpleEscapeCheck[i] = simpleEscapeSequence(i) ? 1 : 0; + simpleEscapeMap[i] = simpleEscapeSequence(i); +} + + +function State(input, options) { + this.input = input; + + this.filename = options['filename'] || null; + this.schema = options['schema'] || DEFAULT_SCHEMA; + this.onWarning = options['onWarning'] || null; + // (Hidden) Remove? makes the loader to expect YAML 1.1 documents + // if such documents have no explicit %YAML directive + this.legacy = options['legacy'] || false; + + this.json = options['json'] || false; + this.listener = options['listener'] || null; + + this.implicitTypes = this.schema.compiledImplicit; + this.typeMap = this.schema.compiledTypeMap; + + this.length = input.length; + this.position = 0; + this.line = 0; + this.lineStart = 0; + this.lineIndent = 0; + + // position of first leading tab in the current line, + // used to make sure there are no tabs in the indentation + this.firstTabInLine = -1; + + this.documents = []; + + /* + this.version; + this.checkLineBreaks; + this.tagMap; + this.anchorMap; + this.tag; + this.anchor; + this.kind; + this.result;*/ + +} + + +function generateError(state, message) { + var mark = { + name: state.filename, + buffer: state.input.slice(0, -1), // omit trailing \0 + position: state.position, + line: state.line, + column: state.position - state.lineStart + }; + + mark.snippet = makeSnippet(mark); + + return new YAMLException(message, mark); +} + +function throwError(state, message) { + throw generateError(state, message); +} + +function throwWarning(state, message) { + if (state.onWarning) { + state.onWarning.call(null, generateError(state, message)); + } +} + + +var directiveHandlers = { + + YAML: function handleYamlDirective(state, name, args) { + + var match, major, minor; + + if (state.version !== null) { + throwError(state, 'duplication of %YAML directive'); + } + + if (args.length !== 1) { + throwError(state, 'YAML directive accepts exactly one argument'); + } + + match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]); + + if (match === null) { + throwError(state, 'ill-formed argument of the YAML directive'); + } + + major = parseInt(match[1], 10); + minor = parseInt(match[2], 10); + + if (major !== 1) { + throwError(state, 'unacceptable YAML version of the document'); + } + + state.version = args[0]; + state.checkLineBreaks = (minor < 2); + + if (minor !== 1 && minor !== 2) { + throwWarning(state, 'unsupported YAML version of the document'); + } + }, + + TAG: function handleTagDirective(state, name, args) { + + var handle, prefix; + + if (args.length !== 2) { + throwError(state, 'TAG directive accepts exactly two arguments'); + } + + handle = args[0]; + prefix = args[1]; + + if (!PATTERN_TAG_HANDLE.test(handle)) { + throwError(state, 'ill-formed tag handle (first argument) of the TAG directive'); + } + + if (_hasOwnProperty.call(state.tagMap, handle)) { + throwError(state, 'there is a previously declared suffix for "' + handle + '" tag handle'); + } + + if (!PATTERN_TAG_URI.test(prefix)) { + throwError(state, 'ill-formed tag prefix (second argument) of the TAG directive'); + } + + try { + prefix = decodeURIComponent(prefix); + } catch (err) { + throwError(state, 'tag prefix is malformed: ' + prefix); + } + + state.tagMap[handle] = prefix; + } +}; + + +function captureSegment(state, start, end, checkJson) { + var _position, _length, _character, _result; + + if (start < end) { + _result = state.input.slice(start, end); + + if (checkJson) { + for (_position = 0, _length = _result.length; _position < _length; _position += 1) { + _character = _result.charCodeAt(_position); + if (!(_character === 0x09 || + (0x20 <= _character && _character <= 0x10FFFF))) { + throwError(state, 'expected valid JSON character'); + } + } + } else if (PATTERN_NON_PRINTABLE.test(_result)) { + throwError(state, 'the stream contains non-printable characters'); + } + + state.result += _result; + } +} + +function mergeMappings(state, destination, source, overridableKeys) { + var sourceKeys, key, index, quantity; + + if (!common.isObject(source)) { + throwError(state, 'cannot merge mappings; the provided source object is unacceptable'); + } + + sourceKeys = Object.keys(source); + + for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) { + key = sourceKeys[index]; + + if (!_hasOwnProperty.call(destination, key)) { + destination[key] = source[key]; + overridableKeys[key] = true; + } + } +} + +function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, + startLine, startLineStart, startPos) { + + var index, quantity; + + // The output is a plain object here, so keys can only be strings. + // We need to convert keyNode to a string, but doing so can hang the process + // (deeply nested arrays that explode exponentially using aliases). + if (Array.isArray(keyNode)) { + keyNode = Array.prototype.slice.call(keyNode); + + for (index = 0, quantity = keyNode.length; index < quantity; index += 1) { + if (Array.isArray(keyNode[index])) { + throwError(state, 'nested arrays are not supported inside keys'); + } + + if (typeof keyNode === 'object' && _class(keyNode[index]) === '[object Object]') { + keyNode[index] = '[object Object]'; + } + } + } + + // Avoid code execution in load() via toString property + // (still use its own toString for arrays, timestamps, + // and whatever user schema extensions happen to have @@toStringTag) + if (typeof keyNode === 'object' && _class(keyNode) === '[object Object]') { + keyNode = '[object Object]'; + } + + + keyNode = String(keyNode); + + if (_result === null) { + _result = {}; + } + + if (keyTag === 'tag:yaml.org,2002:merge') { + if (Array.isArray(valueNode)) { + for (index = 0, quantity = valueNode.length; index < quantity; index += 1) { + mergeMappings(state, _result, valueNode[index], overridableKeys); + } + } else { + mergeMappings(state, _result, valueNode, overridableKeys); + } + } else { + if (!state.json && + !_hasOwnProperty.call(overridableKeys, keyNode) && + _hasOwnProperty.call(_result, keyNode)) { + state.line = startLine || state.line; + state.lineStart = startLineStart || state.lineStart; + state.position = startPos || state.position; + throwError(state, 'duplicated mapping key'); + } + + // used for this specific key only because Object.defineProperty is slow + if (keyNode === '__proto__') { + Object.defineProperty(_result, keyNode, { + configurable: true, + enumerable: true, + writable: true, + value: valueNode + }); + } else { + _result[keyNode] = valueNode; + } + delete overridableKeys[keyNode]; + } + + return _result; +} + +function readLineBreak(state) { + var ch; + + ch = state.input.charCodeAt(state.position); + + if (ch === 0x0A/* LF */) { + state.position++; + } else if (ch === 0x0D/* CR */) { + state.position++; + if (state.input.charCodeAt(state.position) === 0x0A/* LF */) { + state.position++; + } + } else { + throwError(state, 'a line break is expected'); + } + + state.line += 1; + state.lineStart = state.position; + state.firstTabInLine = -1; +} + +function skipSeparationSpace(state, allowComments, checkIndent) { + var lineBreaks = 0, + ch = state.input.charCodeAt(state.position); + + while (ch !== 0) { + while (is_WHITE_SPACE(ch)) { + if (ch === 0x09/* Tab */ && state.firstTabInLine === -1) { + state.firstTabInLine = state.position; + } + ch = state.input.charCodeAt(++state.position); + } + + if (allowComments && ch === 0x23/* # */) { + do { + ch = state.input.charCodeAt(++state.position); + } while (ch !== 0x0A/* LF */ && ch !== 0x0D/* CR */ && ch !== 0); + } + + if (is_EOL(ch)) { + readLineBreak(state); + + ch = state.input.charCodeAt(state.position); + lineBreaks++; + state.lineIndent = 0; + + while (ch === 0x20/* Space */) { + state.lineIndent++; + ch = state.input.charCodeAt(++state.position); + } + } else { + break; + } + } + + if (checkIndent !== -1 && lineBreaks !== 0 && state.lineIndent < checkIndent) { + throwWarning(state, 'deficient indentation'); + } + + return lineBreaks; +} + +function testDocumentSeparator(state) { + var _position = state.position, + ch; + + ch = state.input.charCodeAt(_position); + + // Condition state.position === state.lineStart is tested + // in parent on each call, for efficiency. No needs to test here again. + if ((ch === 0x2D/* - */ || ch === 0x2E/* . */) && + ch === state.input.charCodeAt(_position + 1) && + ch === state.input.charCodeAt(_position + 2)) { + + _position += 3; + + ch = state.input.charCodeAt(_position); + + if (ch === 0 || is_WS_OR_EOL(ch)) { + return true; + } + } + + return false; +} + +function writeFoldedLines(state, count) { + if (count === 1) { + state.result += ' '; + } else if (count > 1) { + state.result += common.repeat('\n', count - 1); + } +} + + +function readPlainScalar(state, nodeIndent, withinFlowCollection) { + var preceding, + following, + captureStart, + captureEnd, + hasPendingContent, + _line, + _lineStart, + _lineIndent, + _kind = state.kind, + _result = state.result, + ch; + + ch = state.input.charCodeAt(state.position); + + if (is_WS_OR_EOL(ch) || + is_FLOW_INDICATOR(ch) || + ch === 0x23/* # */ || + ch === 0x26/* & */ || + ch === 0x2A/* * */ || + ch === 0x21/* ! */ || + ch === 0x7C/* | */ || + ch === 0x3E/* > */ || + ch === 0x27/* ' */ || + ch === 0x22/* " */ || + ch === 0x25/* % */ || + ch === 0x40/* @ */ || + ch === 0x60/* ` */) { + return false; + } + + if (ch === 0x3F/* ? */ || ch === 0x2D/* - */) { + following = state.input.charCodeAt(state.position + 1); + + if (is_WS_OR_EOL(following) || + withinFlowCollection && is_FLOW_INDICATOR(following)) { + return false; + } + } + + state.kind = 'scalar'; + state.result = ''; + captureStart = captureEnd = state.position; + hasPendingContent = false; + + while (ch !== 0) { + if (ch === 0x3A/* : */) { + following = state.input.charCodeAt(state.position + 1); + + if (is_WS_OR_EOL(following) || + withinFlowCollection && is_FLOW_INDICATOR(following)) { + break; + } + + } else if (ch === 0x23/* # */) { + preceding = state.input.charCodeAt(state.position - 1); + + if (is_WS_OR_EOL(preceding)) { + break; + } + + } else if ((state.position === state.lineStart && testDocumentSeparator(state)) || + withinFlowCollection && is_FLOW_INDICATOR(ch)) { + break; + + } else if (is_EOL(ch)) { + _line = state.line; + _lineStart = state.lineStart; + _lineIndent = state.lineIndent; + skipSeparationSpace(state, false, -1); + + if (state.lineIndent >= nodeIndent) { + hasPendingContent = true; + ch = state.input.charCodeAt(state.position); + continue; + } else { + state.position = captureEnd; + state.line = _line; + state.lineStart = _lineStart; + state.lineIndent = _lineIndent; + break; + } + } + + if (hasPendingContent) { + captureSegment(state, captureStart, captureEnd, false); + writeFoldedLines(state, state.line - _line); + captureStart = captureEnd = state.position; + hasPendingContent = false; + } + + if (!is_WHITE_SPACE(ch)) { + captureEnd = state.position + 1; + } + + ch = state.input.charCodeAt(++state.position); + } + + captureSegment(state, captureStart, captureEnd, false); + + if (state.result) { + return true; + } + + state.kind = _kind; + state.result = _result; + return false; +} + +function readSingleQuotedScalar(state, nodeIndent) { + var ch, + captureStart, captureEnd; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x27/* ' */) { + return false; + } + + state.kind = 'scalar'; + state.result = ''; + state.position++; + captureStart = captureEnd = state.position; + + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + if (ch === 0x27/* ' */) { + captureSegment(state, captureStart, state.position, true); + ch = state.input.charCodeAt(++state.position); + + if (ch === 0x27/* ' */) { + captureStart = state.position; + state.position++; + captureEnd = state.position; + } else { + return true; + } + + } else if (is_EOL(ch)) { + captureSegment(state, captureStart, captureEnd, true); + writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent)); + captureStart = captureEnd = state.position; + + } else if (state.position === state.lineStart && testDocumentSeparator(state)) { + throwError(state, 'unexpected end of the document within a single quoted scalar'); + + } else { + state.position++; + captureEnd = state.position; + } + } + + throwError(state, 'unexpected end of the stream within a single quoted scalar'); +} + +function readDoubleQuotedScalar(state, nodeIndent) { + var captureStart, + captureEnd, + hexLength, + hexResult, + tmp, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x22/* " */) { + return false; + } + + state.kind = 'scalar'; + state.result = ''; + state.position++; + captureStart = captureEnd = state.position; + + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + if (ch === 0x22/* " */) { + captureSegment(state, captureStart, state.position, true); + state.position++; + return true; + + } else if (ch === 0x5C/* \ */) { + captureSegment(state, captureStart, state.position, true); + ch = state.input.charCodeAt(++state.position); + + if (is_EOL(ch)) { + skipSeparationSpace(state, false, nodeIndent); + + // TODO: rework to inline fn with no type cast? + } else if (ch < 256 && simpleEscapeCheck[ch]) { + state.result += simpleEscapeMap[ch]; + state.position++; + + } else if ((tmp = escapedHexLen(ch)) > 0) { + hexLength = tmp; + hexResult = 0; + + for (; hexLength > 0; hexLength--) { + ch = state.input.charCodeAt(++state.position); + + if ((tmp = fromHexCode(ch)) >= 0) { + hexResult = (hexResult << 4) + tmp; + + } else { + throwError(state, 'expected hexadecimal character'); + } + } + + state.result += charFromCodepoint(hexResult); + + state.position++; + + } else { + throwError(state, 'unknown escape sequence'); + } + + captureStart = captureEnd = state.position; + + } else if (is_EOL(ch)) { + captureSegment(state, captureStart, captureEnd, true); + writeFoldedLines(state, skipSeparationSpace(state, false, nodeIndent)); + captureStart = captureEnd = state.position; + + } else if (state.position === state.lineStart && testDocumentSeparator(state)) { + throwError(state, 'unexpected end of the document within a double quoted scalar'); + + } else { + state.position++; + captureEnd = state.position; + } + } + + throwError(state, 'unexpected end of the stream within a double quoted scalar'); +} + +function readFlowCollection(state, nodeIndent) { + var readNext = true, + _line, + _lineStart, + _pos, + _tag = state.tag, + _result, + _anchor = state.anchor, + following, + terminator, + isPair, + isExplicitPair, + isMapping, + overridableKeys = Object.create(null), + keyNode, + keyTag, + valueNode, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch === 0x5B/* [ */) { + terminator = 0x5D;/* ] */ + isMapping = false; + _result = []; + } else if (ch === 0x7B/* { */) { + terminator = 0x7D;/* } */ + isMapping = true; + _result = {}; + } else { + return false; + } + + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + + ch = state.input.charCodeAt(++state.position); + + while (ch !== 0) { + skipSeparationSpace(state, true, nodeIndent); + + ch = state.input.charCodeAt(state.position); + + if (ch === terminator) { + state.position++; + state.tag = _tag; + state.anchor = _anchor; + state.kind = isMapping ? 'mapping' : 'sequence'; + state.result = _result; + return true; + } else if (!readNext) { + throwError(state, 'missed comma between flow collection entries'); + } else if (ch === 0x2C/* , */) { + // "flow collection entries can never be completely empty", as per YAML 1.2, section 7.4 + throwError(state, "expected the node content, but found ','"); + } + + keyTag = keyNode = valueNode = null; + isPair = isExplicitPair = false; + + if (ch === 0x3F/* ? */) { + following = state.input.charCodeAt(state.position + 1); + + if (is_WS_OR_EOL(following)) { + isPair = isExplicitPair = true; + state.position++; + skipSeparationSpace(state, true, nodeIndent); + } + } + + _line = state.line; // Save the current line. + _lineStart = state.lineStart; + _pos = state.position; + composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); + keyTag = state.tag; + keyNode = state.result; + skipSeparationSpace(state, true, nodeIndent); + + ch = state.input.charCodeAt(state.position); + + if ((isExplicitPair || state.line === _line) && ch === 0x3A/* : */) { + isPair = true; + ch = state.input.charCodeAt(++state.position); + skipSeparationSpace(state, true, nodeIndent); + composeNode(state, nodeIndent, CONTEXT_FLOW_IN, false, true); + valueNode = state.result; + } + + if (isMapping) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos); + } else if (isPair) { + _result.push(storeMappingPair(state, null, overridableKeys, keyTag, keyNode, valueNode, _line, _lineStart, _pos)); + } else { + _result.push(keyNode); + } + + skipSeparationSpace(state, true, nodeIndent); + + ch = state.input.charCodeAt(state.position); + + if (ch === 0x2C/* , */) { + readNext = true; + ch = state.input.charCodeAt(++state.position); + } else { + readNext = false; + } + } + + throwError(state, 'unexpected end of the stream within a flow collection'); +} + +function readBlockScalar(state, nodeIndent) { + var captureStart, + folding, + chomping = CHOMPING_CLIP, + didReadContent = false, + detectedIndent = false, + textIndent = nodeIndent, + emptyLines = 0, + atMoreIndented = false, + tmp, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch === 0x7C/* | */) { + folding = false; + } else if (ch === 0x3E/* > */) { + folding = true; + } else { + return false; + } + + state.kind = 'scalar'; + state.result = ''; + + while (ch !== 0) { + ch = state.input.charCodeAt(++state.position); + + if (ch === 0x2B/* + */ || ch === 0x2D/* - */) { + if (CHOMPING_CLIP === chomping) { + chomping = (ch === 0x2B/* + */) ? CHOMPING_KEEP : CHOMPING_STRIP; + } else { + throwError(state, 'repeat of a chomping mode identifier'); + } + + } else if ((tmp = fromDecimalCode(ch)) >= 0) { + if (tmp === 0) { + throwError(state, 'bad explicit indentation width of a block scalar; it cannot be less than one'); + } else if (!detectedIndent) { + textIndent = nodeIndent + tmp - 1; + detectedIndent = true; + } else { + throwError(state, 'repeat of an indentation width identifier'); + } + + } else { + break; + } + } + + if (is_WHITE_SPACE(ch)) { + do { ch = state.input.charCodeAt(++state.position); } + while (is_WHITE_SPACE(ch)); + + if (ch === 0x23/* # */) { + do { ch = state.input.charCodeAt(++state.position); } + while (!is_EOL(ch) && (ch !== 0)); + } + } + + while (ch !== 0) { + readLineBreak(state); + state.lineIndent = 0; + + ch = state.input.charCodeAt(state.position); + + while ((!detectedIndent || state.lineIndent < textIndent) && + (ch === 0x20/* Space */)) { + state.lineIndent++; + ch = state.input.charCodeAt(++state.position); + } + + if (!detectedIndent && state.lineIndent > textIndent) { + textIndent = state.lineIndent; + } + + if (is_EOL(ch)) { + emptyLines++; + continue; + } + + // End of the scalar. + if (state.lineIndent < textIndent) { + + // Perform the chomping. + if (chomping === CHOMPING_KEEP) { + state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); + } else if (chomping === CHOMPING_CLIP) { + if (didReadContent) { // i.e. only if the scalar is not empty. + state.result += '\n'; + } + } + + // Break this `while` cycle and go to the funciton's epilogue. + break; + } + + // Folded style: use fancy rules to handle line breaks. + if (folding) { + + // Lines starting with white space characters (more-indented lines) are not folded. + if (is_WHITE_SPACE(ch)) { + atMoreIndented = true; + // except for the first content line (cf. Example 8.1) + state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); + + // End of more-indented block. + } else if (atMoreIndented) { + atMoreIndented = false; + state.result += common.repeat('\n', emptyLines + 1); + + // Just one line break - perceive as the same line. + } else if (emptyLines === 0) { + if (didReadContent) { // i.e. only if we have already read some scalar content. + state.result += ' '; + } + + // Several line breaks - perceive as different lines. + } else { + state.result += common.repeat('\n', emptyLines); + } + + // Literal style: just add exact number of line breaks between content lines. + } else { + // Keep all line breaks except the header line break. + state.result += common.repeat('\n', didReadContent ? 1 + emptyLines : emptyLines); + } + + didReadContent = true; + detectedIndent = true; + emptyLines = 0; + captureStart = state.position; + + while (!is_EOL(ch) && (ch !== 0)) { + ch = state.input.charCodeAt(++state.position); + } + + captureSegment(state, captureStart, state.position, false); + } + + return true; +} + +function readBlockSequence(state, nodeIndent) { + var _line, + _tag = state.tag, + _anchor = state.anchor, + _result = [], + following, + detected = false, + ch; + + // there is a leading tab before this token, so it can't be a block sequence/mapping; + // it can still be flow sequence/mapping or a scalar + if (state.firstTabInLine !== -1) return false; + + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + + ch = state.input.charCodeAt(state.position); + + while (ch !== 0) { + if (state.firstTabInLine !== -1) { + state.position = state.firstTabInLine; + throwError(state, 'tab characters must not be used in indentation'); + } + + if (ch !== 0x2D/* - */) { + break; + } + + following = state.input.charCodeAt(state.position + 1); + + if (!is_WS_OR_EOL(following)) { + break; + } + + detected = true; + state.position++; + + if (skipSeparationSpace(state, true, -1)) { + if (state.lineIndent <= nodeIndent) { + _result.push(null); + ch = state.input.charCodeAt(state.position); + continue; + } + } + + _line = state.line; + composeNode(state, nodeIndent, CONTEXT_BLOCK_IN, false, true); + _result.push(state.result); + skipSeparationSpace(state, true, -1); + + ch = state.input.charCodeAt(state.position); + + if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) { + throwError(state, 'bad indentation of a sequence entry'); + } else if (state.lineIndent < nodeIndent) { + break; + } + } + + if (detected) { + state.tag = _tag; + state.anchor = _anchor; + state.kind = 'sequence'; + state.result = _result; + return true; + } + return false; +} + +function readBlockMapping(state, nodeIndent, flowIndent) { + var following, + allowCompact, + _line, + _keyLine, + _keyLineStart, + _keyPos, + _tag = state.tag, + _anchor = state.anchor, + _result = {}, + overridableKeys = Object.create(null), + keyTag = null, + keyNode = null, + valueNode = null, + atExplicitKey = false, + detected = false, + ch; + + // there is a leading tab before this token, so it can't be a block sequence/mapping; + // it can still be flow sequence/mapping or a scalar + if (state.firstTabInLine !== -1) return false; + + if (state.anchor !== null) { + state.anchorMap[state.anchor] = _result; + } + + ch = state.input.charCodeAt(state.position); + + while (ch !== 0) { + if (!atExplicitKey && state.firstTabInLine !== -1) { + state.position = state.firstTabInLine; + throwError(state, 'tab characters must not be used in indentation'); + } + + following = state.input.charCodeAt(state.position + 1); + _line = state.line; // Save the current line. + + // + // Explicit notation case. There are two separate blocks: + // first for the key (denoted by "?") and second for the value (denoted by ":") + // + if ((ch === 0x3F/* ? */ || ch === 0x3A/* : */) && is_WS_OR_EOL(following)) { + + if (ch === 0x3F/* ? */) { + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); + keyTag = keyNode = valueNode = null; + } + + detected = true; + atExplicitKey = true; + allowCompact = true; + + } else if (atExplicitKey) { + // i.e. 0x3A/* : */ === character after the explicit key. + atExplicitKey = false; + allowCompact = true; + + } else { + throwError(state, 'incomplete explicit mapping pair; a key node is missed; or followed by a non-tabulated empty line'); + } + + state.position += 1; + ch = following; + + // + // Implicit notation case. Flow-style node as the key first, then ":", and the value. + // + } else { + _keyLine = state.line; + _keyLineStart = state.lineStart; + _keyPos = state.position; + + if (!composeNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true)) { + // Neither implicit nor explicit notation. + // Reading is done. Go to the epilogue. + break; + } + + if (state.line === _line) { + ch = state.input.charCodeAt(state.position); + + while (is_WHITE_SPACE(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (ch === 0x3A/* : */) { + ch = state.input.charCodeAt(++state.position); + + if (!is_WS_OR_EOL(ch)) { + throwError(state, 'a whitespace character is expected after the key-value separator within a block mapping'); + } + + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); + keyTag = keyNode = valueNode = null; + } + + detected = true; + atExplicitKey = false; + allowCompact = false; + keyTag = state.tag; + keyNode = state.result; + + } else if (detected) { + throwError(state, 'can not read an implicit mapping pair; a colon is missed'); + + } else { + state.tag = _tag; + state.anchor = _anchor; + return true; // Keep the result of `composeNode`. + } + + } else if (detected) { + throwError(state, 'can not read a block mapping entry; a multiline key may not be an implicit key'); + + } else { + state.tag = _tag; + state.anchor = _anchor; + return true; // Keep the result of `composeNode`. + } + } + + // + // Common reading code for both explicit and implicit notations. + // + if (state.line === _line || state.lineIndent > nodeIndent) { + if (atExplicitKey) { + _keyLine = state.line; + _keyLineStart = state.lineStart; + _keyPos = state.position; + } + + if (composeNode(state, nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) { + if (atExplicitKey) { + keyNode = state.result; + } else { + valueNode = state.result; + } + } + + if (!atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valueNode, _keyLine, _keyLineStart, _keyPos); + keyTag = keyNode = valueNode = null; + } + + skipSeparationSpace(state, true, -1); + ch = state.input.charCodeAt(state.position); + } + + if ((state.line === _line || state.lineIndent > nodeIndent) && (ch !== 0)) { + throwError(state, 'bad indentation of a mapping entry'); + } else if (state.lineIndent < nodeIndent) { + break; + } + } + + // + // Epilogue. + // + + // Special case: last mapping's node contains only the key in explicit notation. + if (atExplicitKey) { + storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, null, _keyLine, _keyLineStart, _keyPos); + } + + // Expose the resulting mapping. + if (detected) { + state.tag = _tag; + state.anchor = _anchor; + state.kind = 'mapping'; + state.result = _result; + } + + return detected; +} + +function readTagProperty(state) { + var _position, + isVerbatim = false, + isNamed = false, + tagHandle, + tagName, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x21/* ! */) return false; + + if (state.tag !== null) { + throwError(state, 'duplication of a tag property'); + } + + ch = state.input.charCodeAt(++state.position); + + if (ch === 0x3C/* < */) { + isVerbatim = true; + ch = state.input.charCodeAt(++state.position); + + } else if (ch === 0x21/* ! */) { + isNamed = true; + tagHandle = '!!'; + ch = state.input.charCodeAt(++state.position); + + } else { + tagHandle = '!'; + } + + _position = state.position; + + if (isVerbatim) { + do { ch = state.input.charCodeAt(++state.position); } + while (ch !== 0 && ch !== 0x3E/* > */); + + if (state.position < state.length) { + tagName = state.input.slice(_position, state.position); + ch = state.input.charCodeAt(++state.position); + } else { + throwError(state, 'unexpected end of the stream within a verbatim tag'); + } + } else { + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + + if (ch === 0x21/* ! */) { + if (!isNamed) { + tagHandle = state.input.slice(_position - 1, state.position + 1); + + if (!PATTERN_TAG_HANDLE.test(tagHandle)) { + throwError(state, 'named tag handle cannot contain such characters'); + } + + isNamed = true; + _position = state.position + 1; + } else { + throwError(state, 'tag suffix cannot contain exclamation marks'); + } + } + + ch = state.input.charCodeAt(++state.position); + } + + tagName = state.input.slice(_position, state.position); + + if (PATTERN_FLOW_INDICATORS.test(tagName)) { + throwError(state, 'tag suffix cannot contain flow indicator characters'); + } + } + + if (tagName && !PATTERN_TAG_URI.test(tagName)) { + throwError(state, 'tag name cannot contain such characters: ' + tagName); + } + + try { + tagName = decodeURIComponent(tagName); + } catch (err) { + throwError(state, 'tag name is malformed: ' + tagName); + } + + if (isVerbatim) { + state.tag = tagName; + + } else if (_hasOwnProperty.call(state.tagMap, tagHandle)) { + state.tag = state.tagMap[tagHandle] + tagName; + + } else if (tagHandle === '!') { + state.tag = '!' + tagName; + + } else if (tagHandle === '!!') { + state.tag = 'tag:yaml.org,2002:' + tagName; + + } else { + throwError(state, 'undeclared tag handle "' + tagHandle + '"'); + } + + return true; +} + +function readAnchorProperty(state) { + var _position, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x26/* & */) return false; + + if (state.anchor !== null) { + throwError(state, 'duplication of an anchor property'); + } + + ch = state.input.charCodeAt(++state.position); + _position = state.position; + + while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (state.position === _position) { + throwError(state, 'name of an anchor node must contain at least one character'); + } + + state.anchor = state.input.slice(_position, state.position); + return true; +} + +function readAlias(state) { + var _position, alias, + ch; + + ch = state.input.charCodeAt(state.position); + + if (ch !== 0x2A/* * */) return false; + + ch = state.input.charCodeAt(++state.position); + _position = state.position; + + while (ch !== 0 && !is_WS_OR_EOL(ch) && !is_FLOW_INDICATOR(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (state.position === _position) { + throwError(state, 'name of an alias node must contain at least one character'); + } + + alias = state.input.slice(_position, state.position); + + if (!_hasOwnProperty.call(state.anchorMap, alias)) { + throwError(state, 'unidentified alias "' + alias + '"'); + } + + state.result = state.anchorMap[alias]; + skipSeparationSpace(state, true, -1); + return true; +} + +function composeNode(state, parentIndent, nodeContext, allowToSeek, allowCompact) { + var allowBlockStyles, + allowBlockScalars, + allowBlockCollections, + indentStatus = 1, // 1: this>parent, 0: this=parent, -1: this parentIndent) { + indentStatus = 1; + } else if (state.lineIndent === parentIndent) { + indentStatus = 0; + } else if (state.lineIndent < parentIndent) { + indentStatus = -1; + } + } + } + + if (indentStatus === 1) { + while (readTagProperty(state) || readAnchorProperty(state)) { + if (skipSeparationSpace(state, true, -1)) { + atNewLine = true; + allowBlockCollections = allowBlockStyles; + + if (state.lineIndent > parentIndent) { + indentStatus = 1; + } else if (state.lineIndent === parentIndent) { + indentStatus = 0; + } else if (state.lineIndent < parentIndent) { + indentStatus = -1; + } + } else { + allowBlockCollections = false; + } + } + } + + if (allowBlockCollections) { + allowBlockCollections = atNewLine || allowCompact; + } + + if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) { + if (CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext) { + flowIndent = parentIndent; + } else { + flowIndent = parentIndent + 1; + } + + blockIndent = state.position - state.lineStart; + + if (indentStatus === 1) { + if (allowBlockCollections && + (readBlockSequence(state, blockIndent) || + readBlockMapping(state, blockIndent, flowIndent)) || + readFlowCollection(state, flowIndent)) { + hasContent = true; + } else { + if ((allowBlockScalars && readBlockScalar(state, flowIndent)) || + readSingleQuotedScalar(state, flowIndent) || + readDoubleQuotedScalar(state, flowIndent)) { + hasContent = true; + + } else if (readAlias(state)) { + hasContent = true; + + if (state.tag !== null || state.anchor !== null) { + throwError(state, 'alias node should not have any properties'); + } + + } else if (readPlainScalar(state, flowIndent, CONTEXT_FLOW_IN === nodeContext)) { + hasContent = true; + + if (state.tag === null) { + state.tag = '?'; + } + } + + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + } + } else if (indentStatus === 0) { + // Special case: block sequences are allowed to have same indentation level as the parent. + // http://www.yaml.org/spec/1.2/spec.html#id2799784 + hasContent = allowBlockCollections && readBlockSequence(state, blockIndent); + } + } + + if (state.tag === null) { + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + + } else if (state.tag === '?') { + // Implicit resolving is not allowed for non-scalar types, and '?' + // non-specific tag is only automatically assigned to plain scalars. + // + // We only need to check kind conformity in case user explicitly assigns '?' + // tag, for example like this: "! [0]" + // + if (state.result !== null && state.kind !== 'scalar') { + throwError(state, 'unacceptable node kind for ! tag; it should be "scalar", not "' + state.kind + '"'); + } + + for (typeIndex = 0, typeQuantity = state.implicitTypes.length; typeIndex < typeQuantity; typeIndex += 1) { + type = state.implicitTypes[typeIndex]; + + if (type.resolve(state.result)) { // `state.result` updated in resolver if matched + state.result = type.construct(state.result); + state.tag = type.tag; + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + break; + } + } + } else if (state.tag !== '!') { + if (_hasOwnProperty.call(state.typeMap[state.kind || 'fallback'], state.tag)) { + type = state.typeMap[state.kind || 'fallback'][state.tag]; + } else { + // looking for multi type + type = null; + typeList = state.typeMap.multi[state.kind || 'fallback']; + + for (typeIndex = 0, typeQuantity = typeList.length; typeIndex < typeQuantity; typeIndex += 1) { + if (state.tag.slice(0, typeList[typeIndex].tag.length) === typeList[typeIndex].tag) { + type = typeList[typeIndex]; + break; + } + } + } + + if (!type) { + throwError(state, 'unknown tag !<' + state.tag + '>'); + } + + if (state.result !== null && type.kind !== state.kind) { + throwError(state, 'unacceptable node kind for !<' + state.tag + '> tag; it should be "' + type.kind + '", not "' + state.kind + '"'); + } + + if (!type.resolve(state.result, state.tag)) { // `state.result` updated in resolver if matched + throwError(state, 'cannot resolve a node with !<' + state.tag + '> explicit tag'); + } else { + state.result = type.construct(state.result, state.tag); + if (state.anchor !== null) { + state.anchorMap[state.anchor] = state.result; + } + } + } + + if (state.listener !== null) { + state.listener('close', state); + } + return state.tag !== null || state.anchor !== null || hasContent; +} + +function readDocument(state) { + var documentStart = state.position, + _position, + directiveName, + directiveArgs, + hasDirectives = false, + ch; + + state.version = null; + state.checkLineBreaks = state.legacy; + state.tagMap = Object.create(null); + state.anchorMap = Object.create(null); + + while ((ch = state.input.charCodeAt(state.position)) !== 0) { + skipSeparationSpace(state, true, -1); + + ch = state.input.charCodeAt(state.position); + + if (state.lineIndent > 0 || ch !== 0x25/* % */) { + break; + } + + hasDirectives = true; + ch = state.input.charCodeAt(++state.position); + _position = state.position; + + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + directiveName = state.input.slice(_position, state.position); + directiveArgs = []; + + if (directiveName.length < 1) { + throwError(state, 'directive name must not be less than one character in length'); + } + + while (ch !== 0) { + while (is_WHITE_SPACE(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + if (ch === 0x23/* # */) { + do { ch = state.input.charCodeAt(++state.position); } + while (ch !== 0 && !is_EOL(ch)); + break; + } + + if (is_EOL(ch)) break; + + _position = state.position; + + while (ch !== 0 && !is_WS_OR_EOL(ch)) { + ch = state.input.charCodeAt(++state.position); + } + + directiveArgs.push(state.input.slice(_position, state.position)); + } + + if (ch !== 0) readLineBreak(state); + + if (_hasOwnProperty.call(directiveHandlers, directiveName)) { + directiveHandlers[directiveName](state, directiveName, directiveArgs); + } else { + throwWarning(state, 'unknown document directive "' + directiveName + '"'); + } + } + + skipSeparationSpace(state, true, -1); + + if (state.lineIndent === 0 && + state.input.charCodeAt(state.position) === 0x2D/* - */ && + state.input.charCodeAt(state.position + 1) === 0x2D/* - */ && + state.input.charCodeAt(state.position + 2) === 0x2D/* - */) { + state.position += 3; + skipSeparationSpace(state, true, -1); + + } else if (hasDirectives) { + throwError(state, 'directives end mark is expected'); + } + + composeNode(state, state.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true); + skipSeparationSpace(state, true, -1); + + if (state.checkLineBreaks && + PATTERN_NON_ASCII_LINE_BREAKS.test(state.input.slice(documentStart, state.position))) { + throwWarning(state, 'non-ASCII line breaks are interpreted as content'); + } + + state.documents.push(state.result); + + if (state.position === state.lineStart && testDocumentSeparator(state)) { + + if (state.input.charCodeAt(state.position) === 0x2E/* . */) { + state.position += 3; + skipSeparationSpace(state, true, -1); + } + return; + } + + if (state.position < (state.length - 1)) { + throwError(state, 'end of the stream or a document separator is expected'); + } else { + return; + } +} + + +function loadDocuments(input, options) { + input = String(input); + options = options || {}; + + if (input.length !== 0) { + + // Add tailing `\n` if not exists + if (input.charCodeAt(input.length - 1) !== 0x0A/* LF */ && + input.charCodeAt(input.length - 1) !== 0x0D/* CR */) { + input += '\n'; + } + + // Strip BOM + if (input.charCodeAt(0) === 0xFEFF) { + input = input.slice(1); + } + } + + var state = new State(input, options); + + var nullpos = input.indexOf('\0'); + + if (nullpos !== -1) { + state.position = nullpos; + throwError(state, 'null byte is not allowed in input'); + } + + // Use 0 as string terminator. That significantly simplifies bounds check. + state.input += '\0'; + + while (state.input.charCodeAt(state.position) === 0x20/* Space */) { + state.lineIndent += 1; + state.position += 1; + } + + while (state.position < (state.length - 1)) { + readDocument(state); + } + + return state.documents; +} + + +function loadAll(input, iterator, options) { + if (iterator !== null && typeof iterator === 'object' && typeof options === 'undefined') { + options = iterator; + iterator = null; + } + + var documents = loadDocuments(input, options); + + if (typeof iterator !== 'function') { + return documents; + } + + for (var index = 0, length = documents.length; index < length; index += 1) { + iterator(documents[index]); + } +} + + +function load(input, options) { + var documents = loadDocuments(input, options); + + if (documents.length === 0) { + /*eslint-disable no-undefined*/ + return undefined; + } else if (documents.length === 1) { + return documents[0]; + } + throw new YAMLException('expected a single document in the stream, but found more'); +} + + +module.exports.loadAll = loadAll; +module.exports.load = load; + + +/***/ }), + +/***/ 1082: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +/*eslint-disable max-len*/ + +var YAMLException = __nccwpck_require__(8179); +var Type = __nccwpck_require__(6073); + + +function compileList(schema, name) { + var result = []; + + schema[name].forEach(function (currentType) { + var newIndex = result.length; + + result.forEach(function (previousType, previousIndex) { + if (previousType.tag === currentType.tag && + previousType.kind === currentType.kind && + previousType.multi === currentType.multi) { + + newIndex = previousIndex; + } + }); + + result[newIndex] = currentType; + }); + + return result; +} + + +function compileMap(/* lists... */) { + var result = { + scalar: {}, + sequence: {}, + mapping: {}, + fallback: {}, + multi: { + scalar: [], + sequence: [], + mapping: [], + fallback: [] + } + }, index, length; + + function collectType(type) { + if (type.multi) { + result.multi[type.kind].push(type); + result.multi['fallback'].push(type); + } else { + result[type.kind][type.tag] = result['fallback'][type.tag] = type; + } + } + + for (index = 0, length = arguments.length; index < length; index += 1) { + arguments[index].forEach(collectType); + } + return result; +} + + +function Schema(definition) { + return this.extend(definition); +} + + +Schema.prototype.extend = function extend(definition) { + var implicit = []; + var explicit = []; + + if (definition instanceof Type) { + // Schema.extend(type) + explicit.push(definition); + + } else if (Array.isArray(definition)) { + // Schema.extend([ type1, type2, ... ]) + explicit = explicit.concat(definition); + + } else if (definition && (Array.isArray(definition.implicit) || Array.isArray(definition.explicit))) { + // Schema.extend({ explicit: [ type1, type2, ... ], implicit: [ type1, type2, ... ] }) + if (definition.implicit) implicit = implicit.concat(definition.implicit); + if (definition.explicit) explicit = explicit.concat(definition.explicit); + + } else { + throw new YAMLException('Schema.extend argument should be a Type, [ Type ], ' + + 'or a schema definition ({ implicit: [...], explicit: [...] })'); + } + + implicit.forEach(function (type) { + if (!(type instanceof Type)) { + throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.'); + } + + if (type.loadKind && type.loadKind !== 'scalar') { + throw new YAMLException('There is a non-scalar type in the implicit list of a schema. Implicit resolving of such types is not supported.'); + } + + if (type.multi) { + throw new YAMLException('There is a multi type in the implicit list of a schema. Multi tags can only be listed as explicit.'); + } + }); + + explicit.forEach(function (type) { + if (!(type instanceof Type)) { + throw new YAMLException('Specified list of YAML types (or a single Type object) contains a non-Type object.'); + } + }); + + var result = Object.create(Schema.prototype); + + result.implicit = (this.implicit || []).concat(implicit); + result.explicit = (this.explicit || []).concat(explicit); + + result.compiledImplicit = compileList(result, 'implicit'); + result.compiledExplicit = compileList(result, 'explicit'); + result.compiledTypeMap = compileMap(result.compiledImplicit, result.compiledExplicit); + + return result; +}; + + +module.exports = Schema; + + +/***/ }), + +/***/ 2011: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; +// Standard YAML's Core schema. +// http://www.yaml.org/spec/1.2/spec.html#id2804923 +// +// NOTE: JS-YAML does not support schema-specific tag resolution restrictions. +// So, Core schema has no distinctions from JSON schema is JS-YAML. + + + + + +module.exports = __nccwpck_require__(1035); + + +/***/ }), + +/***/ 8759: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; +// JS-YAML's default schema for `safeLoad` function. +// It is not described in the YAML specification. +// +// This schema is based on standard YAML's Core schema and includes most of +// extra types described at YAML tag repository. (http://yaml.org/type/) + + + + + +module.exports = (__nccwpck_require__(2011).extend)({ + implicit: [ + __nccwpck_require__(9212), + __nccwpck_require__(6104) + ], + explicit: [ + __nccwpck_require__(7900), + __nccwpck_require__(9046), + __nccwpck_require__(6860), + __nccwpck_require__(9548) + ] +}); + + +/***/ }), + +/***/ 8562: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; +// Standard YAML's Failsafe schema. +// http://www.yaml.org/spec/1.2/spec.html#id2802346 + + + + + +var Schema = __nccwpck_require__(1082); + + +module.exports = new Schema({ + explicit: [ + __nccwpck_require__(3619), + __nccwpck_require__(7283), + __nccwpck_require__(6150) + ] +}); + + +/***/ }), + +/***/ 1035: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; +// Standard YAML's JSON schema. +// http://www.yaml.org/spec/1.2/spec.html#id2803231 +// +// NOTE: JS-YAML does not support schema-specific tag resolution restrictions. +// So, this schema is not such strict as defined in the YAML specification. +// It allows numbers in binary notaion, use `Null` and `NULL` as `null`, etc. + + + + + +module.exports = (__nccwpck_require__(8562).extend)({ + implicit: [ + __nccwpck_require__(721), + __nccwpck_require__(4993), + __nccwpck_require__(1615), + __nccwpck_require__(2705) + ] +}); + + +/***/ }), + +/***/ 6975: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + + +var common = __nccwpck_require__(6829); + + +// get snippet for a single line, respecting maxLength +function getLine(buffer, lineStart, lineEnd, position, maxLineLength) { + var head = ''; + var tail = ''; + var maxHalfLength = Math.floor(maxLineLength / 2) - 1; + + if (position - lineStart > maxHalfLength) { + head = ' ... '; + lineStart = position - maxHalfLength + head.length; + } + + if (lineEnd - position > maxHalfLength) { + tail = ' ...'; + lineEnd = position + maxHalfLength - tail.length; + } + + return { + str: head + buffer.slice(lineStart, lineEnd).replace(/\t/g, '→') + tail, + pos: position - lineStart + head.length // relative position + }; +} + + +function padStart(string, max) { + return common.repeat(' ', max - string.length) + string; +} + + +function makeSnippet(mark, options) { + options = Object.create(options || null); + + if (!mark.buffer) return null; + + if (!options.maxLength) options.maxLength = 79; + if (typeof options.indent !== 'number') options.indent = 1; + if (typeof options.linesBefore !== 'number') options.linesBefore = 3; + if (typeof options.linesAfter !== 'number') options.linesAfter = 2; + + var re = /\r?\n|\r|\0/g; + var lineStarts = [ 0 ]; + var lineEnds = []; + var match; + var foundLineNo = -1; + + while ((match = re.exec(mark.buffer))) { + lineEnds.push(match.index); + lineStarts.push(match.index + match[0].length); + + if (mark.position <= match.index && foundLineNo < 0) { + foundLineNo = lineStarts.length - 2; + } + } + + if (foundLineNo < 0) foundLineNo = lineStarts.length - 1; + + var result = '', i, line; + var lineNoLength = Math.min(mark.line + options.linesAfter, lineEnds.length).toString().length; + var maxLineLength = options.maxLength - (options.indent + lineNoLength + 3); + + for (i = 1; i <= options.linesBefore; i++) { + if (foundLineNo - i < 0) break; + line = getLine( + mark.buffer, + lineStarts[foundLineNo - i], + lineEnds[foundLineNo - i], + mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo - i]), + maxLineLength + ); + result = common.repeat(' ', options.indent) + padStart((mark.line - i + 1).toString(), lineNoLength) + + ' | ' + line.str + '\n' + result; + } + + line = getLine(mark.buffer, lineStarts[foundLineNo], lineEnds[foundLineNo], mark.position, maxLineLength); + result += common.repeat(' ', options.indent) + padStart((mark.line + 1).toString(), lineNoLength) + + ' | ' + line.str + '\n'; + result += common.repeat('-', options.indent + lineNoLength + 3 + line.pos) + '^' + '\n'; + + for (i = 1; i <= options.linesAfter; i++) { + if (foundLineNo + i >= lineEnds.length) break; + line = getLine( + mark.buffer, + lineStarts[foundLineNo + i], + lineEnds[foundLineNo + i], + mark.position - (lineStarts[foundLineNo] - lineStarts[foundLineNo + i]), + maxLineLength + ); + result += common.repeat(' ', options.indent) + padStart((mark.line + i + 1).toString(), lineNoLength) + + ' | ' + line.str + '\n'; + } + + return result.replace(/\n$/, ''); +} + + +module.exports = makeSnippet; + + +/***/ }), + +/***/ 6073: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var YAMLException = __nccwpck_require__(8179); + +var TYPE_CONSTRUCTOR_OPTIONS = [ + 'kind', + 'multi', + 'resolve', + 'construct', + 'instanceOf', + 'predicate', + 'represent', + 'representName', + 'defaultStyle', + 'styleAliases' +]; + +var YAML_NODE_KINDS = [ + 'scalar', + 'sequence', + 'mapping' +]; + +function compileStyleAliases(map) { + var result = {}; + + if (map !== null) { + Object.keys(map).forEach(function (style) { + map[style].forEach(function (alias) { + result[String(alias)] = style; + }); + }); + } + + return result; +} + +function Type(tag, options) { + options = options || {}; + + Object.keys(options).forEach(function (name) { + if (TYPE_CONSTRUCTOR_OPTIONS.indexOf(name) === -1) { + throw new YAMLException('Unknown option "' + name + '" is met in definition of "' + tag + '" YAML type.'); + } + }); + + // TODO: Add tag format check. + this.options = options; // keep original options in case user wants to extend this type later + this.tag = tag; + this.kind = options['kind'] || null; + this.resolve = options['resolve'] || function () { return true; }; + this.construct = options['construct'] || function (data) { return data; }; + this.instanceOf = options['instanceOf'] || null; + this.predicate = options['predicate'] || null; + this.represent = options['represent'] || null; + this.representName = options['representName'] || null; + this.defaultStyle = options['defaultStyle'] || null; + this.multi = options['multi'] || false; + this.styleAliases = compileStyleAliases(options['styleAliases'] || null); + + if (YAML_NODE_KINDS.indexOf(this.kind) === -1) { + throw new YAMLException('Unknown kind "' + this.kind + '" is specified for "' + tag + '" YAML type.'); + } +} + +module.exports = Type; + + +/***/ }), + +/***/ 7900: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +/*eslint-disable no-bitwise*/ + + +var Type = __nccwpck_require__(6073); + + +// [ 64, 65, 66 ] -> [ padding, CR, LF ] +var BASE64_MAP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\n\r'; + + +function resolveYamlBinary(data) { + if (data === null) return false; + + var code, idx, bitlen = 0, max = data.length, map = BASE64_MAP; + + // Convert one by one. + for (idx = 0; idx < max; idx++) { + code = map.indexOf(data.charAt(idx)); + + // Skip CR/LF + if (code > 64) continue; + + // Fail on illegal characters + if (code < 0) return false; + + bitlen += 6; + } + + // If there are any bits left, source was corrupted + return (bitlen % 8) === 0; +} + +function constructYamlBinary(data) { + var idx, tailbits, + input = data.replace(/[\r\n=]/g, ''), // remove CR/LF & padding to simplify scan + max = input.length, + map = BASE64_MAP, + bits = 0, + result = []; + + // Collect by 6*4 bits (3 bytes) + + for (idx = 0; idx < max; idx++) { + if ((idx % 4 === 0) && idx) { + result.push((bits >> 16) & 0xFF); + result.push((bits >> 8) & 0xFF); + result.push(bits & 0xFF); + } + + bits = (bits << 6) | map.indexOf(input.charAt(idx)); + } + + // Dump tail + + tailbits = (max % 4) * 6; + + if (tailbits === 0) { + result.push((bits >> 16) & 0xFF); + result.push((bits >> 8) & 0xFF); + result.push(bits & 0xFF); + } else if (tailbits === 18) { + result.push((bits >> 10) & 0xFF); + result.push((bits >> 2) & 0xFF); + } else if (tailbits === 12) { + result.push((bits >> 4) & 0xFF); + } + + return new Uint8Array(result); +} + +function representYamlBinary(object /*, style*/) { + var result = '', bits = 0, idx, tail, + max = object.length, + map = BASE64_MAP; + + // Convert every three bytes to 4 ASCII characters. + + for (idx = 0; idx < max; idx++) { + if ((idx % 3 === 0) && idx) { + result += map[(bits >> 18) & 0x3F]; + result += map[(bits >> 12) & 0x3F]; + result += map[(bits >> 6) & 0x3F]; + result += map[bits & 0x3F]; + } + + bits = (bits << 8) + object[idx]; + } + + // Dump tail + + tail = max % 3; + + if (tail === 0) { + result += map[(bits >> 18) & 0x3F]; + result += map[(bits >> 12) & 0x3F]; + result += map[(bits >> 6) & 0x3F]; + result += map[bits & 0x3F]; + } else if (tail === 2) { + result += map[(bits >> 10) & 0x3F]; + result += map[(bits >> 4) & 0x3F]; + result += map[(bits << 2) & 0x3F]; + result += map[64]; + } else if (tail === 1) { + result += map[(bits >> 2) & 0x3F]; + result += map[(bits << 4) & 0x3F]; + result += map[64]; + result += map[64]; + } + + return result; +} + +function isBinary(obj) { + return Object.prototype.toString.call(obj) === '[object Uint8Array]'; +} + +module.exports = new Type('tag:yaml.org,2002:binary', { + kind: 'scalar', + resolve: resolveYamlBinary, + construct: constructYamlBinary, + predicate: isBinary, + represent: representYamlBinary +}); + + +/***/ }), + +/***/ 4993: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var Type = __nccwpck_require__(6073); + +function resolveYamlBoolean(data) { + if (data === null) return false; + + var max = data.length; + + return (max === 4 && (data === 'true' || data === 'True' || data === 'TRUE')) || + (max === 5 && (data === 'false' || data === 'False' || data === 'FALSE')); +} + +function constructYamlBoolean(data) { + return data === 'true' || + data === 'True' || + data === 'TRUE'; +} + +function isBoolean(object) { + return Object.prototype.toString.call(object) === '[object Boolean]'; +} + +module.exports = new Type('tag:yaml.org,2002:bool', { + kind: 'scalar', + resolve: resolveYamlBoolean, + construct: constructYamlBoolean, + predicate: isBoolean, + represent: { + lowercase: function (object) { return object ? 'true' : 'false'; }, + uppercase: function (object) { return object ? 'TRUE' : 'FALSE'; }, + camelcase: function (object) { return object ? 'True' : 'False'; } + }, + defaultStyle: 'lowercase' +}); + + +/***/ }), + +/***/ 2705: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var common = __nccwpck_require__(6829); +var Type = __nccwpck_require__(6073); + +var YAML_FLOAT_PATTERN = new RegExp( + // 2.5e4, 2.5 and integers + '^(?:[-+]?(?:[0-9][0-9_]*)(?:\\.[0-9_]*)?(?:[eE][-+]?[0-9]+)?' + + // .2e4, .2 + // special case, seems not from spec + '|\\.[0-9_]+(?:[eE][-+]?[0-9]+)?' + + // .inf + '|[-+]?\\.(?:inf|Inf|INF)' + + // .nan + '|\\.(?:nan|NaN|NAN))$'); + +function resolveYamlFloat(data) { + if (data === null) return false; + + if (!YAML_FLOAT_PATTERN.test(data) || + // Quick hack to not allow integers end with `_` + // Probably should update regexp & check speed + data[data.length - 1] === '_') { + return false; + } + + return true; +} + +function constructYamlFloat(data) { + var value, sign; + + value = data.replace(/_/g, '').toLowerCase(); + sign = value[0] === '-' ? -1 : 1; + + if ('+-'.indexOf(value[0]) >= 0) { + value = value.slice(1); + } + + if (value === '.inf') { + return (sign === 1) ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY; + + } else if (value === '.nan') { + return NaN; + } + return sign * parseFloat(value, 10); +} + + +var SCIENTIFIC_WITHOUT_DOT = /^[-+]?[0-9]+e/; + +function representYamlFloat(object, style) { + var res; + + if (isNaN(object)) { + switch (style) { + case 'lowercase': return '.nan'; + case 'uppercase': return '.NAN'; + case 'camelcase': return '.NaN'; + } + } else if (Number.POSITIVE_INFINITY === object) { + switch (style) { + case 'lowercase': return '.inf'; + case 'uppercase': return '.INF'; + case 'camelcase': return '.Inf'; + } + } else if (Number.NEGATIVE_INFINITY === object) { + switch (style) { + case 'lowercase': return '-.inf'; + case 'uppercase': return '-.INF'; + case 'camelcase': return '-.Inf'; + } + } else if (common.isNegativeZero(object)) { + return '-0.0'; + } + + res = object.toString(10); + + // JS stringifier can build scientific format without dots: 5e-100, + // while YAML requres dot: 5.e-100. Fix it with simple hack + + return SCIENTIFIC_WITHOUT_DOT.test(res) ? res.replace('e', '.e') : res; +} + +function isFloat(object) { + return (Object.prototype.toString.call(object) === '[object Number]') && + (object % 1 !== 0 || common.isNegativeZero(object)); +} + +module.exports = new Type('tag:yaml.org,2002:float', { + kind: 'scalar', + resolve: resolveYamlFloat, + construct: constructYamlFloat, + predicate: isFloat, + represent: representYamlFloat, + defaultStyle: 'lowercase' +}); + + +/***/ }), + +/***/ 1615: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var common = __nccwpck_require__(6829); +var Type = __nccwpck_require__(6073); + +function isHexCode(c) { + return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)) || + ((0x41/* A */ <= c) && (c <= 0x46/* F */)) || + ((0x61/* a */ <= c) && (c <= 0x66/* f */)); +} + +function isOctCode(c) { + return ((0x30/* 0 */ <= c) && (c <= 0x37/* 7 */)); +} + +function isDecCode(c) { + return ((0x30/* 0 */ <= c) && (c <= 0x39/* 9 */)); +} + +function resolveYamlInteger(data) { + if (data === null) return false; + + var max = data.length, + index = 0, + hasDigits = false, + ch; + + if (!max) return false; + + ch = data[index]; + + // sign + if (ch === '-' || ch === '+') { + ch = data[++index]; + } + + if (ch === '0') { + // 0 + if (index + 1 === max) return true; + ch = data[++index]; + + // base 2, base 8, base 16 + + if (ch === 'b') { + // base 2 + index++; + + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (ch !== '0' && ch !== '1') return false; + hasDigits = true; + } + return hasDigits && ch !== '_'; + } + + + if (ch === 'x') { + // base 16 + index++; + + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (!isHexCode(data.charCodeAt(index))) return false; + hasDigits = true; + } + return hasDigits && ch !== '_'; + } + + + if (ch === 'o') { + // base 8 + index++; + + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (!isOctCode(data.charCodeAt(index))) return false; + hasDigits = true; + } + return hasDigits && ch !== '_'; + } + } + + // base 10 (except 0) + + // value should not start with `_`; + if (ch === '_') return false; + + for (; index < max; index++) { + ch = data[index]; + if (ch === '_') continue; + if (!isDecCode(data.charCodeAt(index))) { + return false; + } + hasDigits = true; + } + + // Should have digits and should not end with `_` + if (!hasDigits || ch === '_') return false; + + return true; +} + +function constructYamlInteger(data) { + var value = data, sign = 1, ch; + + if (value.indexOf('_') !== -1) { + value = value.replace(/_/g, ''); + } + + ch = value[0]; + + if (ch === '-' || ch === '+') { + if (ch === '-') sign = -1; + value = value.slice(1); + ch = value[0]; + } + + if (value === '0') return 0; + + if (ch === '0') { + if (value[1] === 'b') return sign * parseInt(value.slice(2), 2); + if (value[1] === 'x') return sign * parseInt(value.slice(2), 16); + if (value[1] === 'o') return sign * parseInt(value.slice(2), 8); + } + + return sign * parseInt(value, 10); +} + +function isInteger(object) { + return (Object.prototype.toString.call(object)) === '[object Number]' && + (object % 1 === 0 && !common.isNegativeZero(object)); +} + +module.exports = new Type('tag:yaml.org,2002:int', { + kind: 'scalar', + resolve: resolveYamlInteger, + construct: constructYamlInteger, + predicate: isInteger, + represent: { + binary: function (obj) { return obj >= 0 ? '0b' + obj.toString(2) : '-0b' + obj.toString(2).slice(1); }, + octal: function (obj) { return obj >= 0 ? '0o' + obj.toString(8) : '-0o' + obj.toString(8).slice(1); }, + decimal: function (obj) { return obj.toString(10); }, + /* eslint-disable max-len */ + hexadecimal: function (obj) { return obj >= 0 ? '0x' + obj.toString(16).toUpperCase() : '-0x' + obj.toString(16).toUpperCase().slice(1); } + }, + defaultStyle: 'decimal', + styleAliases: { + binary: [ 2, 'bin' ], + octal: [ 8, 'oct' ], + decimal: [ 10, 'dec' ], + hexadecimal: [ 16, 'hex' ] + } +}); + + +/***/ }), + +/***/ 6150: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var Type = __nccwpck_require__(6073); + +module.exports = new Type('tag:yaml.org,2002:map', { + kind: 'mapping', + construct: function (data) { return data !== null ? data : {}; } +}); + + +/***/ }), + +/***/ 6104: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var Type = __nccwpck_require__(6073); + +function resolveYamlMerge(data) { + return data === '<<' || data === null; +} + +module.exports = new Type('tag:yaml.org,2002:merge', { + kind: 'scalar', + resolve: resolveYamlMerge +}); + + +/***/ }), + +/***/ 721: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var Type = __nccwpck_require__(6073); + +function resolveYamlNull(data) { + if (data === null) return true; + + var max = data.length; + + return (max === 1 && data === '~') || + (max === 4 && (data === 'null' || data === 'Null' || data === 'NULL')); +} + +function constructYamlNull() { + return null; +} + +function isNull(object) { + return object === null; +} + +module.exports = new Type('tag:yaml.org,2002:null', { + kind: 'scalar', + resolve: resolveYamlNull, + construct: constructYamlNull, + predicate: isNull, + represent: { + canonical: function () { return '~'; }, + lowercase: function () { return 'null'; }, + uppercase: function () { return 'NULL'; }, + camelcase: function () { return 'Null'; }, + empty: function () { return ''; } + }, + defaultStyle: 'lowercase' +}); + + +/***/ }), + +/***/ 9046: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var Type = __nccwpck_require__(6073); + +var _hasOwnProperty = Object.prototype.hasOwnProperty; +var _toString = Object.prototype.toString; + +function resolveYamlOmap(data) { + if (data === null) return true; + + var objectKeys = [], index, length, pair, pairKey, pairHasKey, + object = data; + + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; + pairHasKey = false; + + if (_toString.call(pair) !== '[object Object]') return false; + + for (pairKey in pair) { + if (_hasOwnProperty.call(pair, pairKey)) { + if (!pairHasKey) pairHasKey = true; + else return false; + } + } + + if (!pairHasKey) return false; + + if (objectKeys.indexOf(pairKey) === -1) objectKeys.push(pairKey); + else return false; + } + + return true; +} + +function constructYamlOmap(data) { + return data !== null ? data : []; +} + +module.exports = new Type('tag:yaml.org,2002:omap', { + kind: 'sequence', + resolve: resolveYamlOmap, + construct: constructYamlOmap +}); + + +/***/ }), + +/***/ 6860: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var Type = __nccwpck_require__(6073); + +var _toString = Object.prototype.toString; + +function resolveYamlPairs(data) { + if (data === null) return true; + + var index, length, pair, keys, result, + object = data; + + result = new Array(object.length); + + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; + + if (_toString.call(pair) !== '[object Object]') return false; + + keys = Object.keys(pair); + + if (keys.length !== 1) return false; + + result[index] = [ keys[0], pair[keys[0]] ]; + } + + return true; +} + +function constructYamlPairs(data) { + if (data === null) return []; + + var index, length, pair, keys, result, + object = data; + + result = new Array(object.length); + + for (index = 0, length = object.length; index < length; index += 1) { + pair = object[index]; + + keys = Object.keys(pair); + + result[index] = [ keys[0], pair[keys[0]] ]; + } + + return result; +} + +module.exports = new Type('tag:yaml.org,2002:pairs', { + kind: 'sequence', + resolve: resolveYamlPairs, + construct: constructYamlPairs +}); + + +/***/ }), + +/***/ 7283: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var Type = __nccwpck_require__(6073); + +module.exports = new Type('tag:yaml.org,2002:seq', { + kind: 'sequence', + construct: function (data) { return data !== null ? data : []; } +}); + + +/***/ }), + +/***/ 9548: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var Type = __nccwpck_require__(6073); + +var _hasOwnProperty = Object.prototype.hasOwnProperty; + +function resolveYamlSet(data) { + if (data === null) return true; + + var key, object = data; + + for (key in object) { + if (_hasOwnProperty.call(object, key)) { + if (object[key] !== null) return false; + } + } + + return true; +} + +function constructYamlSet(data) { + return data !== null ? data : {}; +} + +module.exports = new Type('tag:yaml.org,2002:set', { + kind: 'mapping', + resolve: resolveYamlSet, + construct: constructYamlSet +}); + + +/***/ }), + +/***/ 3619: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var Type = __nccwpck_require__(6073); + +module.exports = new Type('tag:yaml.org,2002:str', { + kind: 'scalar', + construct: function (data) { return data !== null ? data : ''; } +}); + + +/***/ }), + +/***/ 9212: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; + + +var Type = __nccwpck_require__(6073); + +var YAML_DATE_REGEXP = new RegExp( + '^([0-9][0-9][0-9][0-9])' + // [1] year + '-([0-9][0-9])' + // [2] month + '-([0-9][0-9])$'); // [3] day + +var YAML_TIMESTAMP_REGEXP = new RegExp( + '^([0-9][0-9][0-9][0-9])' + // [1] year + '-([0-9][0-9]?)' + // [2] month + '-([0-9][0-9]?)' + // [3] day + '(?:[Tt]|[ \\t]+)' + // ... + '([0-9][0-9]?)' + // [4] hour + ':([0-9][0-9])' + // [5] minute + ':([0-9][0-9])' + // [6] second + '(?:\\.([0-9]*))?' + // [7] fraction + '(?:[ \\t]*(Z|([-+])([0-9][0-9]?)' + // [8] tz [9] tz_sign [10] tz_hour + '(?::([0-9][0-9]))?))?$'); // [11] tz_minute + +function resolveYamlTimestamp(data) { + if (data === null) return false; + if (YAML_DATE_REGEXP.exec(data) !== null) return true; + if (YAML_TIMESTAMP_REGEXP.exec(data) !== null) return true; + return false; +} + +function constructYamlTimestamp(data) { + var match, year, month, day, hour, minute, second, fraction = 0, + delta = null, tz_hour, tz_minute, date; + + match = YAML_DATE_REGEXP.exec(data); + if (match === null) match = YAML_TIMESTAMP_REGEXP.exec(data); + + if (match === null) throw new Error('Date resolve error'); + + // match: [1] year [2] month [3] day + + year = +(match[1]); + month = +(match[2]) - 1; // JS month starts with 0 + day = +(match[3]); + + if (!match[4]) { // no hour + return new Date(Date.UTC(year, month, day)); + } + + // match: [4] hour [5] minute [6] second [7] fraction + + hour = +(match[4]); + minute = +(match[5]); + second = +(match[6]); + + if (match[7]) { + fraction = match[7].slice(0, 3); + while (fraction.length < 3) { // milli-seconds + fraction += '0'; + } + fraction = +fraction; + } + + // match: [8] tz [9] tz_sign [10] tz_hour [11] tz_minute + + if (match[9]) { + tz_hour = +(match[10]); + tz_minute = +(match[11] || 0); + delta = (tz_hour * 60 + tz_minute) * 60000; // delta in mili-seconds + if (match[9] === '-') delta = -delta; + } + + date = new Date(Date.UTC(year, month, day, hour, minute, second, fraction)); + + if (delta) date.setTime(date.getTime() - delta); + + return date; +} + +function representYamlTimestamp(object /*, style*/) { + return object.toISOString(); +} + +module.exports = new Type('tag:yaml.org,2002:timestamp', { + kind: 'scalar', + resolve: resolveYamlTimestamp, + construct: constructYamlTimestamp, + instanceOf: Date, + represent: representYamlTimestamp +}); + + /***/ }), /***/ 5891: @@ -7748,7 +11856,7 @@ module.exports = function(num) { if (v !== undefined) module.exports = v; } else if (typeof define === "function" && define.amd) { - define(["require", "exports", "./scanner"], factory); + define(["require", "exports", "./scanner", "./string-intern"], factory); } })(function () { /*--------------------------------------------------------------------------------------------- @@ -7759,6 +11867,7 @@ module.exports = function(num) { Object.defineProperty(exports, "__esModule", ({ value: true })); exports.isEOL = exports.format = void 0; const scanner_1 = __nccwpck_require__(2122); + const string_intern_1 = __nccwpck_require__(2347); function format(documentText, range, options) { let initialIndentLevel; let formatText; @@ -7787,24 +11896,31 @@ module.exports = function(num) { rangeEnd = documentText.length; } const eol = getEOL(options, documentText); + const eolFastPathSupported = string_intern_1.supportedEols.includes(eol); let numberLineBreaks = 0; let indentLevel = 0; let indentValue; if (options.insertSpaces) { - indentValue = repeat(' ', options.tabSize || 4); + indentValue = string_intern_1.cachedSpaces[options.tabSize || 4] ?? repeat(string_intern_1.cachedSpaces[1], options.tabSize || 4); } else { indentValue = '\t'; } + const indentType = indentValue === '\t' ? '\t' : ' '; let scanner = (0, scanner_1.createScanner)(formatText, false); let hasError = false; function newLinesAndIndent() { if (numberLineBreaks > 1) { return repeat(eol, numberLineBreaks) + repeat(indentValue, initialIndentLevel + indentLevel); } - else { + const amountOfSpaces = indentValue.length * (initialIndentLevel + indentLevel); + if (!eolFastPathSupported || amountOfSpaces > string_intern_1.cachedBreakLinesWithSpaces[indentType][eol].length) { return eol + repeat(indentValue, initialIndentLevel + indentLevel); } + if (amountOfSpaces <= 0) { + return eol; + } + return string_intern_1.cachedBreakLinesWithSpaces[indentType][eol][amountOfSpaces]; } function scanNext() { let token = scanner.scan(); @@ -7833,7 +11949,9 @@ module.exports = function(num) { } if (firstToken !== 17 /* SyntaxKind.EOF */) { let firstTokenStart = scanner.getTokenOffset() + formatTextStart; - let initialIndent = repeat(indentValue, initialIndentLevel); + let initialIndent = (indentValue.length * initialIndentLevel < 20) && options.insertSpaces + ? string_intern_1.cachedSpaces[indentValue.length * initialIndentLevel] + : repeat(indentValue, initialIndentLevel); addEdit(initialIndent, formatTextStart, firstTokenStart); } while (firstToken !== 17 /* SyntaxKind.EOF */) { @@ -7843,7 +11961,7 @@ module.exports = function(num) { let needsLineBreak = false; while (numberLineBreaks === 0 && (secondToken === 12 /* SyntaxKind.LineCommentTrivia */ || secondToken === 13 /* SyntaxKind.BlockCommentTrivia */)) { let commentTokenStart = scanner.getTokenOffset() + formatTextStart; - addEdit(' ', firstTokenEnd, commentTokenStart); + addEdit(string_intern_1.cachedSpaces[1], firstTokenEnd, commentTokenStart); firstTokenEnd = scanner.getTokenOffset() + scanner.getTokenLength() + formatTextStart; needsLineBreak = secondToken === 12 /* SyntaxKind.LineCommentTrivia */; replaceContent = needsLineBreak ? newLinesAndIndent() : ''; @@ -7858,7 +11976,7 @@ module.exports = function(num) { replaceContent = newLinesAndIndent(); } else if (options.keepLines) { - replaceContent = ' '; + replaceContent = string_intern_1.cachedSpaces[1]; } } else if (secondToken === 4 /* SyntaxKind.CloseBracketToken */) { @@ -7870,7 +11988,7 @@ module.exports = function(num) { replaceContent = newLinesAndIndent(); } else if (options.keepLines) { - replaceContent = ' '; + replaceContent = string_intern_1.cachedSpaces[1]; } } else { @@ -7882,7 +12000,7 @@ module.exports = function(num) { replaceContent = newLinesAndIndent(); } else { - replaceContent = ' '; + replaceContent = string_intern_1.cachedSpaces[1]; } break; case 5 /* SyntaxKind.CommaToken */: @@ -7890,7 +12008,7 @@ module.exports = function(num) { replaceContent = newLinesAndIndent(); } else { - replaceContent = ' '; + replaceContent = string_intern_1.cachedSpaces[1]; } break; case 12 /* SyntaxKind.LineCommentTrivia */: @@ -7901,7 +12019,7 @@ module.exports = function(num) { replaceContent = newLinesAndIndent(); } else if (!needsLineBreak) { - replaceContent = ' '; + replaceContent = string_intern_1.cachedSpaces[1]; } break; case 6 /* SyntaxKind.ColonToken */: @@ -7909,7 +12027,7 @@ module.exports = function(num) { replaceContent = newLinesAndIndent(); } else if (!needsLineBreak) { - replaceContent = ' '; + replaceContent = string_intern_1.cachedSpaces[1]; } break; case 10 /* SyntaxKind.StringLiteral */: @@ -7931,7 +12049,7 @@ module.exports = function(num) { } else { if ((secondToken === 12 /* SyntaxKind.LineCommentTrivia */ || secondToken === 13 /* SyntaxKind.BlockCommentTrivia */) && !needsLineBreak) { - replaceContent = ' '; + replaceContent = string_intern_1.cachedSpaces[1]; } else if (secondToken !== 5 /* SyntaxKind.CommaToken */ && secondToken !== 17 /* SyntaxKind.EOF */) { hasError = true; @@ -7974,7 +12092,7 @@ module.exports = function(num) { const tabSize = options.tabSize || 4; while (i < content.length) { let ch = content.charAt(i); - if (ch === ' ') { + if (ch === string_intern_1.cachedSpaces[1]) { nChars++; } else if (ch === '\t') { @@ -9134,6 +13252,55 @@ module.exports = function(num) { }); +/***/ }), + +/***/ 2347: +/***/ ((module, exports) => { + +(function (factory) { + if ( true && typeof module.exports === "object") { + var v = factory(require, exports); + if (v !== undefined) module.exports = v; + } + else if (typeof define === "function" && define.amd) { + define(["require", "exports"], factory); + } +})(function () { + "use strict"; + Object.defineProperty(exports, "__esModule", ({ value: true })); + exports.supportedEols = exports.cachedBreakLinesWithSpaces = exports.cachedSpaces = void 0; + exports.cachedSpaces = new Array(20).fill(0).map((_, index) => { + return ' '.repeat(index); + }); + const maxCachedValues = 200; + exports.cachedBreakLinesWithSpaces = { + ' ': { + '\n': new Array(maxCachedValues).fill(0).map((_, index) => { + return '\n' + ' '.repeat(index); + }), + '\r': new Array(maxCachedValues).fill(0).map((_, index) => { + return '\r' + ' '.repeat(index); + }), + '\r\n': new Array(maxCachedValues).fill(0).map((_, index) => { + return '\r\n' + ' '.repeat(index); + }), + }, + '\t': { + '\n': new Array(maxCachedValues).fill(0).map((_, index) => { + return '\n' + '\t'.repeat(index); + }), + '\r': new Array(maxCachedValues).fill(0).map((_, index) => { + return '\r' + '\t'.repeat(index); + }), + '\r\n': new Array(maxCachedValues).fill(0).map((_, index) => { + return '\r\n' + '\t'.repeat(index); + }), + } + }; + exports.supportedEols = ['\n', '\r', '\r\n']; +}); + + /***/ }), /***/ 245: @@ -9173,7 +13340,7 @@ module.exports = function(num) { ScanError[ScanError["InvalidUnicode"] = 4] = "InvalidUnicode"; ScanError[ScanError["InvalidEscapeCharacter"] = 5] = "InvalidEscapeCharacter"; ScanError[ScanError["InvalidCharacter"] = 6] = "InvalidCharacter"; - })(ScanError = exports.ScanError || (exports.ScanError = {})); + })(ScanError || (exports.ScanError = ScanError = {})); var SyntaxKind; (function (SyntaxKind) { SyntaxKind[SyntaxKind["OpenBraceToken"] = 1] = "OpenBraceToken"; @@ -9193,7 +13360,7 @@ module.exports = function(num) { SyntaxKind[SyntaxKind["Trivia"] = 15] = "Trivia"; SyntaxKind[SyntaxKind["Unknown"] = 16] = "Unknown"; SyntaxKind[SyntaxKind["EOF"] = 17] = "EOF"; - })(SyntaxKind = exports.SyntaxKind || (exports.SyntaxKind = {})); + })(SyntaxKind || (exports.SyntaxKind = SyntaxKind = {})); /** * For a given offset, evaluate the location in the JSON document. Each segment in the location path is either a property name or an array index. */ @@ -9251,7 +13418,7 @@ module.exports = function(num) { ParseErrorCode[ParseErrorCode["InvalidUnicode"] = 14] = "InvalidUnicode"; ParseErrorCode[ParseErrorCode["InvalidEscapeCharacter"] = 15] = "InvalidEscapeCharacter"; ParseErrorCode[ParseErrorCode["InvalidCharacter"] = 16] = "InvalidCharacter"; - })(ParseErrorCode = exports.ParseErrorCode || (exports.ParseErrorCode = {})); + })(ParseErrorCode || (exports.ParseErrorCode = ParseErrorCode = {})); function printParseErrorCode(code) { switch (code) { case 1 /* ParseErrorCode.InvalidSymbol */: return 'InvalidSymbol'; @@ -10386,7 +14553,7 @@ function isWhiteSpace(code) { // Currently without astral characters support. function isPunctChar(ch) { - return ucmicro__namespace.P.test(ch); + return ucmicro__namespace.P.test(ch) || ucmicro__namespace.S.test(ch); } // Markdown ASCII punctuation characters. @@ -10569,7 +14736,6 @@ function parseLinkDestination(str, start, max) { const result = { ok: false, pos: 0, - lines: 0, str: '' }; if (str.charCodeAt(pos) === 0x3C /* < */) { @@ -10648,50 +14814,66 @@ function parseLinkDestination(str, start, max) { // Parse link title // -function parseLinkTitle(str, start, max) { - let code, marker; - let lines = 0; - let pos = start; - const result = { - ok: false, - pos: 0, - lines: 0, - str: '' - }; - if (pos >= max) { - return result; - } - marker = str.charCodeAt(pos); - if (marker !== 0x22 /* " */ && marker !== 0x27 /* ' */ && marker !== 0x28 /* ( */) { - return result; - } - pos++; - // if opening marker is "(", switch it to closing marker ")" - if (marker === 0x28) { - marker = 0x29; +// Parse link title within `str` in [start, max] range, +// or continue previous parsing if `prev_state` is defined (equal to result of last execution). +// +function parseLinkTitle(str, start, max, prev_state) { + let code; + let pos = start; + const state = { + // if `true`, this is a valid link title + ok: false, + // if `true`, this link can be continued on the next line + can_continue: false, + // if `ok`, it's the position of the first character after the closing marker + pos: 0, + // if `ok`, it's the unescaped title + str: '', + // expected closing marker character code + marker: 0 + }; + if (prev_state) { + // this is a continuation of a previous parseLinkTitle call on the next line, + // used in reference links only + state.str = prev_state.str; + state.marker = prev_state.marker; + } else { + if (pos >= max) { + return state; + } + let marker = str.charCodeAt(pos); + if (marker !== 0x22 /* " */ && marker !== 0x27 /* ' */ && marker !== 0x28 /* ( */) { + return state; + } + start++; + pos++; + + // if opening marker is "(", switch it to closing marker ")" + if (marker === 0x28) { + marker = 0x29; + } + state.marker = marker; } while (pos < max) { code = str.charCodeAt(pos); - if (code === marker) { - result.pos = pos + 1; - result.lines = lines; - result.str = unescapeAll(str.slice(start + 1, pos)); - result.ok = true; - return result; - } else if (code === 0x28 /* ( */ && marker === 0x29 /* ) */) { - return result; - } else if (code === 0x0A) { - lines++; + if (code === state.marker) { + state.pos = pos + 1; + state.str += unescapeAll(str.slice(start, pos)); + state.ok = true; + return state; + } else if (code === 0x28 /* ( */ && state.marker === 0x29 /* ) */) { + return state; } else if (code === 0x5C /* \ */ && pos + 1 < max) { pos++; - if (str.charCodeAt(pos) === 0x0A) { - lines++; - } } pos++; } - return result; + + // no closing marker found, but this link title may continue on the next line (for references) + state.can_continue = true; + state.str += unescapeAll(str.slice(start, pos)); + return state; } // Just a shortcut for bulk export @@ -10819,7 +15001,7 @@ function Renderer() { * } * ``` * - * See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js) + * See [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs) * for more details and examples. **/ this.rules = assign({}, default_rules); @@ -12241,6 +16423,14 @@ StateBlock.prototype.Token = Token; // GFM table, https://github.github.com/gfm/#tables-extension- + +// Limit the amount of empty autocompleted cells in a table, +// see https://github.com/markdown-it/markdown-it/issues/1000, +// +// Both pulldown-cmark and commonmark-hs limit the number of cells this way to ~200k. +// We set it to 65k, which can expand user input by a factor of x370 +// (256x256 square is 1.8kB expanded into 650kB). +const MAX_AUTOCOMPLETED_CELLS = 0x10000; function getLine(state, line) { const pos = state.bMarks[line] + state.tShift[line]; const max = state.eMarks[line]; @@ -12392,6 +16582,7 @@ function table(state, startLine, endLine, silent) { state.push('tr_close', 'tr', -1); state.push('thead_close', 'thead', -1); let tbodyLines; + let autocompletedCells = 0; for (nextLine = startLine + 2; nextLine < endLine; nextLine++) { if (state.sCount[nextLine] < state.blkIndent) { break; @@ -12416,6 +16607,13 @@ function table(state, startLine, endLine, silent) { columns = escapedSplit(lineText); if (columns.length && columns[0] === '') columns.shift(); if (columns.length && columns[columns.length - 1] === '') columns.pop(); + + // note: autocomplete count can be negative if user specifies more columns than header, + // but that does not affect intended use (which is limiting expansion) + autocompletedCells += columnCount - columns.length; + if (autocompletedCells > MAX_AUTOCOMPLETED_CELLS) { + break; + } if (nextLine === startLine + 2) { const token_tbo = state.push('tbody_open', 'tbody', 1); token_tbo.map = tbodyLines = [startLine + 2, 0]; @@ -13113,7 +17311,6 @@ function list(state, startLine, endLine, silent) { } function reference(state, startLine, _endLine, silent) { - let lines = 0; let pos = state.bMarks[startLine] + state.tShift[startLine]; let max = state.eMarks[startLine]; let nextLine = startLine + 1; @@ -13125,51 +17322,50 @@ function reference(state, startLine, _endLine, silent) { if (state.src.charCodeAt(pos) !== 0x5B /* [ */) { return false; } - - // Simple check to quickly interrupt scan on [link](url) at the start of line. - // Can be useful on practice: https://github.com/markdown-it/markdown-it/issues/54 - while (++pos < max) { - if (state.src.charCodeAt(pos) === 0x5D /* ] */ && state.src.charCodeAt(pos - 1) !== 0x5C /* \ */) { - if (pos + 1 === max) { - return false; - } - if (state.src.charCodeAt(pos + 1) !== 0x3A /* : */) { - return false; - } - break; + function getNextLine(nextLine) { + const endLine = state.lineMax; + if (nextLine >= endLine || state.isEmpty(nextLine)) { + // empty line or end of input + return null; } - } - const endLine = state.lineMax; + let isContinuation = false; - // jump line-by-line until empty one or EOF - const terminatorRules = state.md.block.ruler.getRules('reference'); - const oldParentType = state.parentType; - state.parentType = 'reference'; - for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) { // this would be a code block normally, but after paragraph // it's considered a lazy continuation regardless of what's there if (state.sCount[nextLine] - state.blkIndent > 3) { - continue; + isContinuation = true; } // quirk for blockquotes, this line should already be checked by that rule if (state.sCount[nextLine] < 0) { - continue; + isContinuation = true; } + if (!isContinuation) { + const terminatorRules = state.md.block.ruler.getRules('reference'); + const oldParentType = state.parentType; + state.parentType = 'reference'; - // Some tags can terminate paragraph without empty line. - let terminate = false; - for (let i = 0, l = terminatorRules.length; i < l; i++) { - if (terminatorRules[i](state, nextLine, endLine, true)) { - terminate = true; - break; + // Some tags can terminate paragraph without empty line. + let terminate = false; + for (let i = 0, l = terminatorRules.length; i < l; i++) { + if (terminatorRules[i](state, nextLine, endLine, true)) { + terminate = true; + break; + } + } + state.parentType = oldParentType; + if (terminate) { + // terminated by another block + return null; } } - if (terminate) { - break; - } + const pos = state.bMarks[nextLine] + state.tShift[nextLine]; + const max = state.eMarks[nextLine]; + + // max + 1 explicitly includes the newline + return state.src.slice(pos, max + 1); } - const str = state.getLines(startLine, nextLine, state.blkIndent, false).trim(); + let str = state.src.slice(pos, max + 1); max = str.length; let labelEnd = -1; for (pos = 1; pos < max; pos++) { @@ -13180,11 +17376,21 @@ function reference(state, startLine, _endLine, silent) { labelEnd = pos; break; } else if (ch === 0x0A /* \n */) { - lines++; + const lineContent = getNextLine(nextLine); + if (lineContent !== null) { + str += lineContent; + max = str.length; + nextLine++; + } } else if (ch === 0x5C /* \ */) { pos++; if (pos < max && str.charCodeAt(pos) === 0x0A) { - lines++; + const lineContent = getNextLine(nextLine); + if (lineContent !== null) { + str += lineContent; + max = str.length; + nextLine++; + } } } } @@ -13197,7 +17403,12 @@ function reference(state, startLine, _endLine, silent) { for (pos = labelEnd + 2; pos < max; pos++) { const ch = str.charCodeAt(pos); if (ch === 0x0A) { - lines++; + const lineContent = getNextLine(nextLine); + if (lineContent !== null) { + str += lineContent; + max = str.length; + nextLine++; + } } else if (isSpace(ch)) ; else { break; } @@ -13214,11 +17425,10 @@ function reference(state, startLine, _endLine, silent) { return false; } pos = destRes.pos; - lines += destRes.lines; // save cursor state, we could require to rollback later const destEndPos = pos; - const destEndLineNo = lines; + const destEndLineNo = nextLine; // [label]: destination 'title' // ^^^ skipping those spaces @@ -13226,7 +17436,12 @@ function reference(state, startLine, _endLine, silent) { for (; pos < max; pos++) { const ch = str.charCodeAt(pos); if (ch === 0x0A) { - lines++; + const lineContent = getNextLine(nextLine); + if (lineContent !== null) { + str += lineContent; + max = str.length; + nextLine++; + } } else if (isSpace(ch)) ; else { break; } @@ -13234,16 +17449,24 @@ function reference(state, startLine, _endLine, silent) { // [label]: destination 'title' // ^^^^^^^ parse this - const titleRes = state.md.helpers.parseLinkTitle(str, pos, max); + let titleRes = state.md.helpers.parseLinkTitle(str, pos, max); + while (titleRes.can_continue) { + const lineContent = getNextLine(nextLine); + if (lineContent === null) break; + str += lineContent; + pos = max; + max = str.length; + nextLine++; + titleRes = state.md.helpers.parseLinkTitle(str, pos, max, titleRes); + } let title; if (pos < max && start !== pos && titleRes.ok) { title = titleRes.str; pos = titleRes.pos; - lines += titleRes.lines; } else { title = ''; pos = destEndPos; - lines = destEndLineNo; + nextLine = destEndLineNo; } // skip trailing spaces until the rest of the line @@ -13260,7 +17483,7 @@ function reference(state, startLine, _endLine, silent) { // but it could still be a valid reference if we roll back title = ''; pos = destEndPos; - lines = destEndLineNo; + nextLine = destEndLineNo; while (pos < max) { const ch = str.charCodeAt(pos); if (!isSpace(ch)) { @@ -13294,15 +17517,14 @@ function reference(state, startLine, _endLine, silent) { href }; } - state.parentType = oldParentType; - state.line = startLine + lines + 1; + state.line = nextLine; return true; } // List of valid html blocks names, according to commonmark spec // https://spec.commonmark.org/0.30/#html-blocks -var block_names = ['address', 'article', 'aside', 'base', 'basefont', 'blockquote', 'body', 'caption', 'center', 'col', 'colgroup', 'dd', 'details', 'dialog', 'dir', 'div', 'dl', 'dt', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hr', 'html', 'iframe', 'legend', 'li', 'link', 'main', 'menu', 'menuitem', 'nav', 'noframes', 'ol', 'optgroup', 'option', 'p', 'param', 'section', 'source', 'summary', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul']; +var block_names = ['address', 'article', 'aside', 'base', 'basefont', 'blockquote', 'body', 'caption', 'center', 'col', 'colgroup', 'dd', 'details', 'dialog', 'dir', 'div', 'dl', 'dt', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hr', 'html', 'iframe', 'legend', 'li', 'link', 'main', 'menu', 'menuitem', 'nav', 'noframes', 'ol', 'optgroup', 'option', 'p', 'param', 'search', 'section', 'summary', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul']; // Regexps to match html elements @@ -13314,9 +17536,9 @@ const attr_value = '(?:' + unquoted + '|' + single_quoted + '|' + double_quoted const attribute = '(?:\\s+' + attr_name + '(?:\\s*=\\s*' + attr_value + ')?)'; const open_tag = '<[A-Za-z][A-Za-z0-9\\-]*' + attribute + '*\\s*\\/?>'; const close_tag = '<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>'; -const comment = '|'; +const comment = ''; const processing = '<[?][\\s\\S]*?[?]>'; -const declaration = ']*>'; +const declaration = ']*>'; const cdata = ''; const HTML_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + '|' + comment + '|' + processing + '|' + declaration + '|' + cdata + ')'); const HTML_OPEN_CLOSE_TAG_RE = new RegExp('^(?:' + open_tag + '|' + close_tag + ')'); @@ -13744,9 +17966,6 @@ StateInline.prototype.push = function (type, tag, nesting) { // - canSplitWord - determine if these markers can be found inside a word // StateInline.prototype.scanDelims = function (start, canSplitWord) { - let can_open, can_close; - let left_flanking = true; - let right_flanking = true; const max = this.posMax; const marker = this.src.charCodeAt(start); @@ -13764,27 +17983,10 @@ StateInline.prototype.scanDelims = function (start, canSplitWord) { const isNextPunctChar = isMdAsciiPunct(nextChar) || isPunctChar(String.fromCharCode(nextChar)); const isLastWhiteSpace = isWhiteSpace(lastChar); const isNextWhiteSpace = isWhiteSpace(nextChar); - if (isNextWhiteSpace) { - left_flanking = false; - } else if (isNextPunctChar) { - if (!(isLastWhiteSpace || isLastPunctChar)) { - left_flanking = false; - } - } - if (isLastWhiteSpace) { - right_flanking = false; - } else if (isLastPunctChar) { - if (!(isNextWhiteSpace || isNextPunctChar)) { - right_flanking = false; - } - } - if (!canSplitWord) { - can_open = left_flanking && (!right_flanking || isLastPunctChar); - can_close = right_flanking && (!left_flanking || isNextPunctChar); - } else { - can_open = left_flanking; - can_close = right_flanking; - } + const left_flanking = !isNextWhiteSpace && (!isNextPunctChar || isLastWhiteSpace || isLastPunctChar); + const right_flanking = !isLastWhiteSpace && (!isLastPunctChar || isNextWhiteSpace || isNextPunctChar); + const can_open = left_flanking && (canSplitWord || !right_flanking || isLastPunctChar); + const can_close = right_flanking && (canSplitWord || !left_flanking || isNextPunctChar); return { can_open, can_close, @@ -13853,7 +18055,7 @@ function text(state, silent) { // Alternative implementation, for memory. // // It costs 10% of performance, but allows extend terminators list, if place it -// to `ParcerInline` property. Probably, will switch to it sometime, such +// to `ParserInline` property. Probably, will switch to it sometime, such // flexibility required. /* @@ -15256,12 +19458,12 @@ function normalizeLinkText(url) { * MarkdownIt provides named presets as a convenience to quickly * enable/disable active syntax rules and options for common use cases. * - * - ["commonmark"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/commonmark.js) - + * - ["commonmark"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/commonmark.mjs) - * configures parser to strict [CommonMark](http://commonmark.org/) mode. - * - [default](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/default.js) - + * - [default](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/default.mjs) - * similar to GFM, used when no preset name given. Enables all available rules, * but still without html, typographer & autolinker. - * - ["zero"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/zero.js) - + * - ["zero"](https://github.com/markdown-it/markdown-it/blob/master/lib/presets/zero.mjs) - * all rules disabled. Useful to quickly setup your config via `.enable()`. * For example, when you need only `bold` and `italic` markup and nothing else. * @@ -15278,7 +19480,7 @@ function normalizeLinkText(url) { * Can be useful for external highlighters. * - __linkify__ - `false`. Set `true` to autoconvert URL-like text to links. * - __typographer__ - `false`. Set `true` to enable [some language-neutral - * replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.js) + + * replacement](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/replacements.mjs) + * quotes beautification (smartquotes). * - __quotes__ - `“”‘’`, String or Array. Double + single quotes replacement * pairs, when typographer enabled and smartquotes on. For example, you can @@ -15403,7 +19605,7 @@ function MarkdownIt(presetName, options) { * md.renderer.rules['my_token'] = myToken * ``` * - * See [[Renderer]] docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.js). + * See [[Renderer]] docs and [source code](https://github.com/markdown-it/markdown-it/blob/master/lib/renderer.mjs). **/ this.renderer = new Renderer(); @@ -15411,7 +19613,7 @@ function MarkdownIt(presetName, options) { * MarkdownIt#linkify -> LinkifyIt * * [linkify-it](https://github.com/markdown-it/linkify-it) instance. - * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.js) + * Used by [linkify](https://github.com/markdown-it/markdown-it/blob/master/lib/rules_core/linkify.mjs) * rule. **/ this.linkify = new LinkifyIt(); @@ -16005,7 +20207,7 @@ module.exports.fencedCodeBlockStyleFor = * Return the string representation of a emphasis or strong markup character. * * @param {string} markup Emphasis or strong string. - * @returns {string} String representation. + * @returns {"asterisk" | "underscore"} String representation. */ module.exports.emphasisOrStrongStyleFor = function emphasisOrStrongStyleFor(markup) { @@ -16044,7 +20246,7 @@ module.exports.headingStyleFor = function headingStyleFor(token) { * Return the string representation of an unordered list marker. * * @param {Object} token MarkdownItToken instance. - * @returns {string} String representation. + * @returns {"asterisk" | "dash" | "plus"} String representation. */ module.exports.unorderedListStyleFor = function unorderedListStyleFor(token) { switch (token.markup) { @@ -16430,10 +20632,10 @@ module.exports.frontMatterHasTitle = /** * Returns an object with information about reference links and images. * - * @param {Object} params RuleParams instance. + * @param {import("../helpers/micromark.cjs").Token[]} tokens Micromark tokens. * @returns {Object} Reference link/image data. */ -function getReferenceLinkImageData(params) { +function getReferenceLinkImageData(tokens) { const normalizeReference = (s) => s.toLowerCase().trim().replace(/\s+/g, " "); const definitions = new Map(); const definitionLineIndices = []; @@ -16442,7 +20644,7 @@ function getReferenceLinkImageData(params) { const shortcuts = new Map(); const filteredTokens = micromark.filterByTypes( - params.parsers.micromark.tokens, + tokens, [ // definitionLineIndices "definition", "gfmFootnoteDefinition", @@ -45929,9 +50131,9 @@ const sliceSize = 1000; /** * Efficiently appends the source array to the destination array. - * @param {Object[]} destination Destination Array. - * @param {Object[]} source Source Array. - * @returns void + * @param {object[]} destination Destination Array. + * @param {object[]} source Source Array. + * @returns {void} */ const appendToArray = (destination, source) => { // NOTE: destination.push(...source) throws "RangeError: Maximum call stack @@ -45981,35 +50183,37 @@ const resolveAndRequire = __nccwpck_require__(5317); // Variables const packageName = "markdownlint-cli2"; -const packageVersion = "0.12.1"; +const packageVersion = "0.13.0"; const libraryName = "markdownlint"; const libraryVersion = markdownlintLibrary.getVersion(); +const bannerMessage = `${packageName} v${packageVersion} (${libraryName} v${libraryVersion})`; const dotOnlySubstitute = "*.{md,markdown}"; const utf8 = "utf8"; // No-op function const noop = () => null; -// Synchronous function to parse JSONC text -const jsoncParse = (text) => { - const { parse, printParseErrorCode } = __nccwpck_require__(245); - const errors = []; - const result = parse(text, errors, { "allowTrailingComma": true }); - if (errors.length > 0) { - const aggregate = errors.map( - (err) => `${printParseErrorCode(err.error)} (offset ${err.offset}, length ${err.length})` - ).join(", "); - throw new Error(`Unable to parse JSON(C) content, ${aggregate}`); - } - return result; -}; +// Gets a JSONC parser +const getJsoncParse = () => __nccwpck_require__(183); -// Synchronous function to parse YAML text -const yamlParse = (text) => (__nccwpck_require__(4083).parse)(text); +// Gets a YAML parser +const getYamlParse = () => __nccwpck_require__(5309); -// Negate a glob +// Gets an ordered array of parsers +const getParsers = () => __nccwpck_require__(2253); + +// Negates a glob const negateGlob = (glob) => `!${glob}`; +// Throws a meaningful exception for an unusable configuration file +const throwForConfigurationFile = (file, error) => { + throw new Error( + `Unable to use configuration file '${file}'; ${error?.message}`, + // @ts-ignore + { "cause": error } + ); +}; + // Return a posix path (even on Windows) const posixPath = (p) => p.split(pathDefault.sep).join(pathPosix.sep); @@ -46024,13 +50228,13 @@ const resolveModulePaths = (dir, modulePaths) => ( ); // Read a JSON(C) or YAML file and return the object -const readConfig = (fs, dir, name, otherwise) => { +const readConfig = (fs, dir, name, otherwise) => () => { const file = pathPosix.join(dir, name); - return () => fs.promises.access(file). + return fs.promises.access(file). then( () => markdownlintReadConfig( file, - [ jsoncParse, yamlParse ], + getParsers(), fs ), otherwise @@ -46038,11 +50242,12 @@ const readConfig = (fs, dir, name, otherwise) => { }; // Import or resolve/require a module ID with a custom directory in the path -const importOrRequireResolve = async (dirs, id, noRequire) => { +const importOrRequireResolve = async (dirOrDirs, id, noRequire) => { if (typeof id === "string") { if (noRequire) { return null; } + const dirs = Array.isArray(dirOrDirs) ? dirOrDirs : [ dirOrDirs ]; const expandId = expandTildePath(id); const errors = []; try { @@ -46051,10 +50256,12 @@ const importOrRequireResolve = async (dirs, id, noRequire) => { errors.push(error); } try { - const fileUrlString = - pathToFileURL(pathDefault.resolve(dirs[0], expandId)).toString(); + const isURL = !pathDefault.isAbsolute(expandId) && URL.canParse(expandId); + const urlString = ( + isURL ? new URL(expandId) : pathToFileURL(pathDefault.resolve(dirs[0], expandId)) + ).toString(); // eslint-disable-next-line no-inline-comments - const module = await import(/* webpackIgnore: true */ fileUrlString); + const module = await import(/* webpackIgnore: true */ urlString); return module.default; } catch (error) { errors.push(error); @@ -46088,11 +50295,11 @@ const importOrRequireIdsAndParams = (dirs, idsAndParams, noRequire) => ( ); // Import or require a JavaScript file and return the exported object -const importOrRequireConfig = (fs, dir, name, noRequire, otherwise) => { - const id = pathPosix.join(dir, name); - return () => fs.promises.access(id). +const importOrRequireConfig = (fs, dir, name, noRequire, otherwise) => () => { + const file = pathPosix.join(dir, name); + return fs.promises.access(file). then( - () => (noRequire ? {} : importOrRequireResolve([ dir ], id)), + () => importOrRequireResolve(dir, name, noRequire), otherwise ); }; @@ -46103,7 +50310,7 @@ const getExtendedConfig = (config, configPath, fs) => { return markdownlintExtendConfig( config, configPath, - [ jsoncParse, yamlParse ], + getParsers(), fs ); } @@ -46117,47 +50324,43 @@ const readOptionsOrConfig = async (configPath, fs, noRequire) => { const dirname = pathPosix.dirname(configPath); let options = null; let config = null; - if (basename.endsWith(".markdownlint-cli2.jsonc")) { - options = jsoncParse(await fs.promises.readFile(configPath, utf8)); - } else if (basename.endsWith(".markdownlint-cli2.yaml")) { - options = yamlParse(await fs.promises.readFile(configPath, utf8)); - } else if ( - basename.endsWith(".markdownlint-cli2.cjs") || - basename.endsWith(".markdownlint-cli2.mjs") - ) { - options = await ( - importOrRequireConfig(fs, dirname, basename, noRequire, noop)() - ); - } else if ( - basename.endsWith(".markdownlint.jsonc") || - basename.endsWith(".markdownlint.json") || - basename.endsWith(".markdownlint.yaml") || - basename.endsWith(".markdownlint.yml") - ) { - config = - await markdownlintReadConfig(configPath, [ jsoncParse, yamlParse ], fs); - } else if ( - basename.endsWith(".markdownlint.cjs") || - basename.endsWith(".markdownlint.mjs") - ) { - config = await ( - importOrRequireConfig(fs, dirname, basename, noRequire, noop)() - ); - } else { - throw new Error( - `Configuration file "${configPath}" is unrecognized; ` + - "its name should be (or end with) one of the supported types " + - "(e.g., \".markdownlint.json\" or \"example.markdownlint-cli2.jsonc\")." - ); + try { + if (basename.endsWith(".markdownlint-cli2.jsonc")) { + options = getJsoncParse()(await fs.promises.readFile(configPath, utf8)); + } else if (basename.endsWith(".markdownlint-cli2.yaml")) { + options = getYamlParse()(await fs.promises.readFile(configPath, utf8)); + } else if ( + basename.endsWith(".markdownlint-cli2.cjs") || + basename.endsWith(".markdownlint-cli2.mjs") + ) { + options = await importOrRequireResolve(dirname, basename, noRequire); + } else if ( + basename.endsWith(".markdownlint.jsonc") || + basename.endsWith(".markdownlint.json") || + basename.endsWith(".markdownlint.yaml") || + basename.endsWith(".markdownlint.yml") + ) { + config = await markdownlintReadConfig(configPath, getParsers(), fs); + } else if ( + basename.endsWith(".markdownlint.cjs") || + basename.endsWith(".markdownlint.mjs") + ) { + config = await importOrRequireResolve(dirname, basename, noRequire); + } else { + throw new Error( + "File name should be (or end with) one of the supported types " + + "(e.g., '.markdownlint.json' or 'example.markdownlint-cli2.jsonc')." + ); + } + } catch (error) { + throwForConfigurationFile(configPath, error); } - if (options) { if (options.config) { options.config = await getExtendedConfig(options.config, configPath, fs); } return options; } - config = await getExtendedConfig(config, configPath, fs); return { config }; }; @@ -46196,7 +50399,10 @@ const processArgv = (argv) => { }; // Show help if missing arguments -const showHelp = (logMessage) => { +const showHelp = (logMessage, showBanner) => { + if (showBanner) { + logMessage(bannerMessage); + } logMessage(`https://github.com/DavidAnson/markdownlint-cli2 Syntax: markdownlint-cli2 glob0 [glob1] [...] [globN] [--config file] [--fix] [--help] @@ -46252,6 +50458,7 @@ const getAndProcessDirInfo = ( noRequire, allowPackageJson ) => { + // Create dirInfo let dirInfo = dirToDirInfo[dir]; if (!dirInfo) { dirInfo = { @@ -46265,46 +50472,41 @@ const getAndProcessDirInfo = ( dirToDirInfo[dir] = dirInfo; // Load markdownlint-cli2 object(s) - const markdownlintCli2Jsonc = - pathPosix.join(dir, ".markdownlint-cli2.jsonc"); - const markdownlintCli2Yaml = - pathPosix.join(dir, ".markdownlint-cli2.yaml"); + const markdownlintCli2Jsonc = pathPosix.join(dir, ".markdownlint-cli2.jsonc"); + const markdownlintCli2Yaml = pathPosix.join(dir, ".markdownlint-cli2.yaml"); + const markdownlintCli2Cjs = pathPosix.join(dir, ".markdownlint-cli2.cjs"); + const markdownlintCli2Mjs = pathPosix.join(dir, ".markdownlint-cli2.mjs"); const packageJson = pathPosix.join(dir, "package.json"); + let file = "[UNKNOWN]"; + // eslint-disable-next-line no-return-assign + const captureFile = (f) => file = f; tasks.push( - fs.promises.access(markdownlintCli2Jsonc). + fs.promises.access(captureFile(markdownlintCli2Jsonc)). then( - () => fs.promises. - readFile(markdownlintCli2Jsonc, utf8). - then(jsoncParse), - () => fs.promises.access(markdownlintCli2Yaml). + () => fs.promises.readFile(file, utf8).then(getJsoncParse()), + () => fs.promises.access(captureFile(markdownlintCli2Yaml)). then( - () => fs.promises. - readFile(markdownlintCli2Yaml, utf8). - then(yamlParse), - importOrRequireConfig( - fs, - dir, - ".markdownlint-cli2.cjs", - noRequire, - importOrRequireConfig( - fs, - dir, - ".markdownlint-cli2.mjs", - noRequire, - () => (allowPackageJson - ? fs.promises.access(packageJson) - // eslint-disable-next-line prefer-promise-reject-errors - : Promise.reject() - ). + () => fs.promises.readFile(file, utf8).then(getYamlParse()), + () => fs.promises.access(captureFile(markdownlintCli2Cjs)). + then( + () => importOrRequireResolve(dir, file, noRequire), + () => fs.promises.access(captureFile(markdownlintCli2Mjs)). then( - () => fs.promises. - readFile(packageJson, utf8). - then(jsoncParse). - then((obj) => obj[packageName]), - noop + () => importOrRequireResolve(dir, file, noRequire), + () => (allowPackageJson + ? fs.promises.access(captureFile(packageJson)) + // eslint-disable-next-line prefer-promise-reject-errors + : Promise.reject() + ). + then( + () => fs.promises. + readFile(file, utf8). + then(getJsoncParse()). + then((obj) => obj[packageName]), + noop + ) ) ) - ) ) ). then((options) => { @@ -46313,7 +50515,7 @@ const getAndProcessDirInfo = ( options.config && getExtendedConfig( options.config, - // Just needs to identify a file in the right directory + // Just need to identify a file in the right directory markdownlintCli2Jsonc, fs ). @@ -46321,6 +50523,9 @@ const getAndProcessDirInfo = ( options.config = config; }); }) + .catch((error) => { + throwForConfigurationFile(file, error); + }) ); // Load markdownlint object(s) @@ -46365,6 +50570,8 @@ const getAndProcessDirInfo = ( }) ); } + + // Return dirInfo return dirInfo; }; @@ -46426,14 +50633,17 @@ const enumerateFiles = async ( baseDir, globPatterns, dirToDirInfo, + gitignore, noRequire ) => { const tasks = []; + /** @type {import("globby").Options} */ const globbyOptions = { "absolute": true, "cwd": baseDir, "dot": true, "expandDirectories": false, + gitignore, "suppressErrors": true, fs }; @@ -46480,7 +50690,7 @@ const enumerateFiles = async ( ); // Process glob patterns // eslint-disable-next-line no-inline-comments - const { globby } = await Promise.resolve(/* import() eager */).then(__nccwpck_require__.bind(__nccwpck_require__, 4480)); + const { globby } = await Promise.resolve(/* import() eager */).then(__nccwpck_require__.bind(__nccwpck_require__, 2826)); const files = [ ...await globby(expandedDirectories, globbyOptions), ...filteredLiteralFiles @@ -46558,6 +50768,7 @@ const createDirInfos = async ( globPatterns, dirToDirInfo, optionsOverride, + gitignore, noRequire ) => { await enumerateFiles( @@ -46566,6 +50777,7 @@ const createDirInfos = async ( baseDir, globPatterns, dirToDirInfo, + gitignore, noRequire ); await enumerateParents( @@ -46722,7 +50934,7 @@ const lintFiles = (fs, dirInfos, fileContents) => { "files": filteredFiles, "strings": filteredStrings, "config": markdownlintConfig || markdownlintOptions.config, - "configParsers": [ jsoncParse, yamlParse ], + "configParsers": getParsers(), "customRules": markdownlintOptions.customRules, "frontMatter": markdownlintOptions.frontMatter ? new RegExp(markdownlintOptions.frontMatter, "u") @@ -46857,10 +51069,6 @@ const main = async (params) => { (directory && pathDefault.resolve(directory)) || process.cwd(); const baseDir = posixPath(baseDirSystem); - // Output banner - logMessage( - `${packageName} v${packageVersion} (${libraryName} v${libraryVersion})` - ); // Merge and process args/argv let fixDefault = false; // eslint-disable-next-line unicorn/no-useless-undefined @@ -46887,22 +51095,24 @@ const main = async (params) => { return true; }); if (shouldShowHelp) { - return showHelp(logMessage); + return showHelp(logMessage, true); } // Read argv configuration file (if relevant and present) let optionsArgv = null; let relativeDir = null; - if (configPath) { - const resolvedConfigPath = - posixPath(pathDefault.resolve(baseDirSystem, configPath)); - optionsArgv = - await readOptionsOrConfig(resolvedConfigPath, fs, noRequire); - relativeDir = pathPosix.dirname(resolvedConfigPath); - } - // Process arguments and get base options - const globPatterns = processArgv(argvFiltered); - const { baseMarkdownlintOptions, dirToDirInfo } = - await getBaseOptions( + let globPatterns = null; + let baseOptions = null; + try { + if (configPath) { + const resolvedConfigPath = + posixPath(pathDefault.resolve(baseDirSystem, configPath)); + optionsArgv = + await readOptionsOrConfig(resolvedConfigPath, fs, noRequire); + relativeDir = pathPosix.dirname(resolvedConfigPath); + } + // Process arguments and get base options + globPatterns = processArgv(argvFiltered); + baseOptions = await getBaseOptions( fs, baseDir, relativeDir, @@ -46912,13 +51122,19 @@ const main = async (params) => { noGlobs, noRequire ); + } finally { + if (!baseOptions?.baseMarkdownlintOptions.noBanner) { + logMessage(bannerMessage); + } + } if ( ((globPatterns.length === 0) && !nonFileContents) || (configPath === null) ) { - return showHelp(logMessage); + return showHelp(logMessage, false); } // Include any file overrides or non-file content + const { baseMarkdownlintOptions, dirToDirInfo } = baseOptions; const resolvedFileContents = {}; for (const file in fileContents) { const resolvedFile = posixPath(pathDefault.resolve(baseDirSystem, file)); @@ -46946,6 +51162,8 @@ const main = async (params) => { globPatterns, dirToDirInfo, optionsOverride, + // https://github.com/sindresorhus/globby/issues/265 + !params.fs && Boolean(baseMarkdownlintOptions.gitignore), noRequire ); // Output linting status @@ -47036,9 +51254,9 @@ if (false) {} /** * Merges two options objects by combining config and replacing properties. - * @param {Object} first First options object. - * @param {Object} second Second options object. - * @returns {Object} Merged options object. + * @param {object} first First options object. + * @param {object} second Second options object. + * @returns {object} Merged options object. */ const mergeOptions = (first, second) => { const merged = { @@ -47059,6 +51277,84 @@ const mergeOptions = (first, second) => { module.exports = mergeOptions; +/***/ }), + +/***/ 183: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; +// @ts-check + + + +const { parse, printParseErrorCode } = __nccwpck_require__(245); + +/** + * Parses a JSONC string, returning the corresponding object. + * @param {string} text String to parse as JSONC. + * @returns {object} Corresponding object. + */ +const jsoncParse = (text) => { + const errors = []; + const result = parse(text, errors, { "allowTrailingComma": true }); + if (errors.length > 0) { + const aggregate = errors.map( + (error) => `${printParseErrorCode(error.error)} (offset ${error.offset}, length ${error.length})` + ).join(", "); + throw new Error(`Unable to parse JSONC content, ${aggregate}`); + } + return result; +}; + +module.exports = jsoncParse; + + +/***/ }), + +/***/ 2253: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; +// @ts-check + + + +const jsoncParse = __nccwpck_require__(183); +const yamlParse = __nccwpck_require__(5309); + +/** + * Array of parser objects ordered by priority. + */ +const parsers = [ + jsoncParse, + yamlParse +]; + +module.exports = parsers; + + +/***/ }), + +/***/ 5309: +/***/ ((module, __unused_webpack_exports, __nccwpck_require__) => { + +"use strict"; +// @ts-check + + + +const yaml = __nccwpck_require__(1917); + +/** + * Parses a YAML string, returning the corresponding object. + * @param {string} text String to parse as YAML. + * @returns {object} Corresponding object. + */ +const yamlParse = (text) => yaml.load(text); + +module.exports = yamlParse; + + /***/ }), /***/ 5317: @@ -47071,10 +51367,10 @@ module.exports = mergeOptions; /** * Wrapper for calling Node's require.resolve/require with an additional path. - * @param {Object} req Node's require implementation (or equivalent). - * @param {String} id Package identifier to require. - * @param {String[]} dirs Directories to include when resolving paths. - * @returns {Object} Exported module content. + * @param {object} req Node's require implementation (or equivalent). + * @param {string} id Package identifier to require. + * @param {string[]} dirs Directories to include when resolving paths. + * @returns {object} Exported module content. */ const resolveAndRequire = (req, id, dirs) => { const resolvePaths = req.resolve.paths ? req.resolve.paths("") : []; @@ -47134,7 +51430,7 @@ module.exports.fixableRuleNames = [ "MD047", "MD049", "MD050", "MD051", "MD053", "MD054" ]; module.exports.homepage = "https://github.com/DavidAnson/markdownlint"; -module.exports.version = "0.33.0"; +module.exports.version = "0.34.0"; /***/ }), @@ -47178,17 +51474,16 @@ function validateRuleList(ruleList, synchronous) { for (const [ index, rule ] of ruleList.entries()) { const customIndex = index - rules.length; // eslint-disable-next-line no-inner-declarations, jsdoc/require-jsdoc - function newError(property) { + function newError(property, value) { return new Error( - "Property '" + property + "' of custom rule at index " + - customIndex + " is incorrect."); + `Property '${property}' of custom rule at index ${customIndex} is incorrect: '${value}'.`); } for (const property of [ "names", "tags" ]) { const value = rule[property]; if (!result && (!value || !Array.isArray(value) || (value.length === 0) || !value.every(helpers.isString) || value.some(helpers.isEmptyString))) { - result = newError(property); + result = newError(property, value); } } for (const propertyInfo of [ @@ -47198,22 +51493,31 @@ function validateRuleList(ruleList, synchronous) { const property = propertyInfo[0]; const value = rule[property]; if (!result && (!value || (typeof value !== propertyInfo[1]))) { - result = newError(property); + result = newError(property, value); } } + if ( + !result && + (rule.parser !== undefined) && + (rule.parser !== "markdownit") && + !((customIndex < 0) && (rule.parser === "micromark")) && + (rule.parser !== "none") + ) { + result = newError("parser", rule.parser); + } if ( !result && rule.information && !helpers.isUrl(rule.information) ) { - result = newError("information"); + result = newError("information", rule.information); } if ( !result && (rule.asynchronous !== undefined) && (typeof rule.asynchronous !== "boolean") ) { - result = newError("asynchronous"); + result = newError("asynchronous", rule.asynchronous); } if (!result && rule.asynchronous && synchronous) { result = new Error( @@ -47708,18 +52012,26 @@ function lintContent( const lines = content.split(helpers.newLineRe); annotateAndFreezeTokens(markdownitTokens, lines); // Create (frozen) parameters for rules - const parsers = Object.freeze({ + /** @type {MarkdownParsers} */ + // @ts-ignore + const parsersMarkdownIt = Object.freeze({ "markdownit": Object.freeze({ "tokens": markdownitTokens - }), + }) + }); + /** @type {MarkdownParsers} */ + // @ts-ignore + const parsersMicromark = Object.freeze({ "micromark": Object.freeze({ "tokens": micromarkTokens }) }); + /** @type {MarkdownParsers} */ + // @ts-ignore + const parsersNone = Object.freeze({}); const paramsBase = { name, - parsers, - "tokens": markdownitTokens, + "parsers": parsersMarkdownIt, "lines": Object.freeze(lines), "frontMatterLines": Object.freeze(frontMatterLines) }; @@ -47728,9 +52040,9 @@ function lintContent( const codeBlockAndSpanRanges = helpers.codeBlockAndSpanRanges(paramsBase, lineMetadata); const flattenedLists = - helpers.flattenLists(paramsBase.parsers.markdownit.tokens); + helpers.flattenLists(markdownitTokens); const referenceLinkImageData = - helpers.getReferenceLinkImageData(paramsBase); + helpers.getReferenceLinkImageData(micromarkTokens); cache.set({ codeBlockAndSpanRanges, flattenedLists, @@ -47739,12 +52051,27 @@ function lintContent( }); // Function to run for each rule let results = []; - // eslint-disable-next-line jsdoc/require-jsdoc - function forRule(rule) { + /** + * @param {Rule} rule Rule. + * @returns {Promise | null} Promise. + */ + const forRule = (rule) => { // Configure rule const ruleName = rule.names[0].toUpperCase(); + const tokens = {}; + let parsers = parsersNone; + if (rule.parser === undefined) { + tokens.tokens = markdownitTokens; + parsers = parsersMarkdownIt; + } else if (rule.parser === "markdownit") { + parsers = parsersMarkdownIt; + } else if (rule.parser === "micromark") { + parsers = parsersMicromark; + } const params = { ...paramsBase, + ...tokens, + parsers, "config": effectiveConfig[ruleName] }; // eslint-disable-next-line jsdoc/require-jsdoc @@ -47866,7 +52193,7 @@ function lintContent( } } return null; - } + }; // eslint-disable-next-line jsdoc/require-jsdoc function formatResults() { // Sort results by rule name by line number @@ -48020,6 +52347,7 @@ function lintInput(options, synchronous, callback) { "description": rule.description, "information": helpers.cloneIfUrl(rule.information), "tags": helpers.cloneIfArray(rule.tags), + "parser": rule.parser, "asynchronous": rule.asynchronous, "function": rule.function })); @@ -48426,19 +52754,45 @@ module.exports = markdownlint; * @returns {void} */ +/* eslint-disable jsdoc/valid-types */ + /** * Rule parameters. * * @typedef {Object} RuleParams * @property {string} name File/string name. - * @property {MarkdownItToken[]} tokens Token objects from markdown-it. - * @property {string[]} lines File/string lines. - * @property {string[]} frontMatterLines Front matter lines. + * @property {MarkdownParsers} parsers Markdown parser data. + * @property {readonly string[]} lines File/string lines. + * @property {readonly string[]} frontMatterLines Front matter lines. * @property {RuleConfiguration} config Rule configuration. */ +/* eslint-enable jsdoc/valid-types */ + /** - * Markdown-It token. + * Markdown parser data. + * + * @typedef {Object} MarkdownParsers + * @property {ParserMarkdownIt} markdownit Markdown parser data from markdown-it (only present when Rule.parser is "markdownit"). + * @property {ParserMicromark} micromark Markdown parser data from micromark (only present when Rule.parser is "micromark"). + */ + +/** + * Markdown parser data from markdown-it. + * + * @typedef {Object} ParserMarkdownIt + * @property {MarkdownItToken[]} tokens Token objects from markdown-it. + */ + +/** + * Markdown parser data from micromark. + * + * @typedef {Object} ParserMicromark + * @property {MicromarkToken[]} tokens Token objects from micromark. + */ + +/** + * markdown-it token. * * @typedef {Object} MarkdownItToken * @property {string[][]} attrs HTML attributes. @@ -48458,6 +52812,22 @@ module.exports = markdownlint; * @property {string} line Line content. */ +/** @typedef {import("markdownlint-micromark").TokenType} MicromarkTokenType */ + +/** + * micromark token. + * + * @typedef {Object} MicromarkToken + * @property {MicromarkTokenType} type Token type. + * @property {number} startLine Start line (1-based). + * @property {number} startColumn Start column (1-based). + * @property {number} endLine End line (1-based). + * @property {number} endColumn End column (1-based). + * @property {string} text Token text. + * @property {MicromarkToken[]} children Child tokens. + * @property {MicromarkToken | null} parent Parent token. + */ + /** * Error-reporting callback. * @@ -48496,6 +52866,7 @@ module.exports = markdownlint; * @property {string} description Rule description. * @property {URL} [information] Link to more information. * @property {string[]} tags Rule tag(s). + * @property {"markdownit" | "micromark" | "none"} parser Parser used. * @property {boolean} [asynchronous] True if asynchronous. * @property {RuleFunction} function Rule implementation. */ @@ -48632,10 +53003,13 @@ module.exports = markdownlint; const { addErrorDetailIf, filterTokens } = __nccwpck_require__(2935); +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD001", "heading-increment" ], "description": "Heading levels should only increment by one level at a time", "tags": [ "headings" ], + "parser": "markdownit", "function": function MD001(params, onError) { let prevLevel = 0; filterTokens(params, "heading_open", function forToken(token) { @@ -48663,10 +53037,13 @@ module.exports = { const { addErrorDetailIf, filterTokens, headingStyleFor } = __nccwpck_require__(2935); +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD003", "heading-style" ], "description": "Heading style", "tags": [ "headings" ], + "parser": "markdownit", "function": function MD003(params, onError) { let style = String(params.config.style || "consistent"); filterTokens(params, "heading_open", function forToken(token) { @@ -48726,10 +53103,13 @@ const differentItemStyle = { }; const validStyles = Object.keys(expectedStyleToMarker); +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD004", "ul-style" ], "description": "Unordered list style", "tags": [ "bullet", "ul" ], + "parser": "none", "function": function MD004(params, onError) { const style = String(params.config.style || "consistent"); let expectedStyle = style; @@ -48797,13 +53177,21 @@ module.exports = { const { addError, addErrorDetailIf } = __nccwpck_require__(2935); const { filterByTypes, inHtmlFlow } = __nccwpck_require__(9901); +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD005", "list-indent" ], "description": "Inconsistent indentation for list items at the same level", "tags": [ "bullet", "ul", "indentation" ], + "parser": "micromark", "function": function MD005(params, onError) { + // eslint-disable-next-line jsdoc/valid-types + /** @type import("../helpers/micromark.cjs").Token[] */ + const micromarkTokens = + // @ts-ignore + params.parsers.micromark.tokens; const lists = filterByTypes( - params.parsers.micromark.tokens, + micromarkTokens, [ "listOrdered", "listUnordered" ] ).filter((list) => !inHtmlFlow(list)); for (const list of lists) { @@ -48879,36 +53267,41 @@ const { addErrorDetailIf } = __nccwpck_require__(2935); const { filterByTypes, getTokenParentOfType, inHtmlFlow } = __nccwpck_require__(9901); -/** - * @typedef {import("../helpers/micromark.cjs").Token} Token - */ - +// eslint-disable-next-line jsdoc/valid-types +/** @type import("markdownlint-micromark").TokenType[] */ const unorderedListTypes = [ "blockQuotePrefix", "listItemPrefix", "listUnordered" ]; +// eslint-disable-next-line jsdoc/valid-types +/** @type import("markdownlint-micromark").TokenType[] */ const unorderedParentTypes = [ "blockQuote", "listOrdered", "listUnordered" ]; +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD007", "ul-indent" ], "description": "Unordered list indentation", "tags": [ "bullet", "ul", "indentation" ], + "parser": "micromark", "function": function MD007(params, onError) { const indent = Number(params.config.indent || 2); const startIndented = !!params.config.start_indented; const startIndent = Number(params.config.start_indent || indent); + // eslint-disable-next-line jsdoc/valid-types + /** @type import("../helpers/micromark.cjs").Token[] */ + const micromarkTokens = + // @ts-ignore + params.parsers.micromark.tokens; const unorderedListNesting = new Map(); let lastBlockQuotePrefix = null; - const tokens = filterByTypes( - params.parsers.micromark.tokens, - unorderedListTypes - ); + const tokens = filterByTypes(micromarkTokens, unorderedListTypes); for (const token of tokens) { const { endColumn, parent, startColumn, startLine, type } = token; if (type === "blockQuotePrefix") { lastBlockQuotePrefix = token; } else if (type === "listUnordered") { let nesting = 0; - /** @type {Token | null} */ + /** @type {import("../helpers/micromark.cjs").Token | null} */ let current = token; while ( (current = getTokenParentOfType(current, unorderedParentTypes)) @@ -48974,10 +53367,13 @@ const { addError, filterTokens, forEachLine, includesSorted, numericSortAscending } = __nccwpck_require__(2935); const { lineMetadata } = __nccwpck_require__(2260); +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD009", "no-trailing-spaces" ], "description": "Trailing spaces", "tags": [ "whitespace" ], + "parser": "markdownit", "function": function MD009(params, onError) { let brSpaces = params.config.br_spaces; brSpaces = Number((brSpaces === undefined) ? 2 : brSpaces); @@ -49070,10 +53466,13 @@ const { codeBlockAndSpanRanges, lineMetadata } = __nccwpck_require__(2260); const tabRe = /\t+/g; +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD010", "no-hard-tabs" ], "description": "Hard tabs", "tags": [ "whitespace", "hard_tab" ], + "parser": "markdownit", "function": function MD010(params, onError) { const codeBlocks = params.config.code_blocks; const includeCode = (codeBlocks === undefined) ? true : !!codeBlocks; @@ -49106,7 +53505,7 @@ module.exports = { onError, lineIndex + 1, "Column: " + column, - null, + undefined, [ column, length ], { "editColumn": column, @@ -49138,10 +53537,13 @@ const { codeBlockAndSpanRanges, lineMetadata } = __nccwpck_require__(2260); const reversedLinkRe = /(^|[^\\])\(([^()]+)\)\[([^\]^][^\]]*)\](?!\()/g; +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD011", "no-reversed-links" ], "description": "Reversed link syntax", "tags": [ "links" ], + "parser": "none", "function": function MD011(params, onError) { const exclusions = codeBlockAndSpanRanges(); forEachLine(lineMetadata(), (line, lineIndex, inCode, onFence) => { @@ -49189,10 +53591,13 @@ module.exports = { const { addErrorDetailIf, forEachLine } = __nccwpck_require__(2935); const { lineMetadata } = __nccwpck_require__(2260); +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD012", "no-multiple-blanks" ], "description": "Multiple consecutive blank lines", "tags": [ "whitespace", "blank_lines" ], + "parser": "none", "function": function MD012(params, onError) { const maximum = Number(params.config.maximum || 1); let count = 0; @@ -49246,10 +53651,13 @@ const tokenTypeMap = { "text": "T" }; +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD013", "line-length" ], "description": "Line length", "tags": [ "line_length" ], + "parser": "markdownit", "function": function MD013(params, onError) { const lineLength = Number(params.config.line_length || 80); const headingLineLength = @@ -49334,10 +53742,13 @@ const { addErrorContext, filterTokens } = __nccwpck_require__(2935); const dollarCommandRe = /^(\s*)(\$\s+)/; +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD014", "commands-show-output" ], "description": "Dollar signs used before commands without showing output", "tags": [ "code" ], + "parser": "markdownit", "function": function MD014(params, onError) { for (const type of [ "code_block", "fence" ]) { filterTokens(params, type, (token) => { @@ -49363,6 +53774,7 @@ module.exports = { const [ i, lineTrim, column, length ] = instance; addErrorContext( onError, + // @ts-ignore i + 1, lineTrim, null, @@ -49394,16 +53806,20 @@ module.exports = { const { addErrorContext, forEachLine } = __nccwpck_require__(2935); const { lineMetadata } = __nccwpck_require__(2260); +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD018", "no-missing-space-atx" ], "description": "No space after hash on atx style heading", "tags": [ "headings", "atx", "spaces" ], + "parser": "none", "function": function MD018(params, onError) { forEachLine(lineMetadata(), (line, lineIndex, inCode) => { if (!inCode && /^#+[^# \t]/.test(line) && !/#\s*$/.test(line) && !line.startsWith("#️⃣")) { + // @ts-ignore const hashCount = /^#+/.exec(line)[0].length; addErrorContext( onError, @@ -49436,10 +53852,13 @@ module.exports = { const { addErrorContext, filterTokens, headingStyleFor } = __nccwpck_require__(2935); +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD019", "no-multiple-space-atx" ], "description": "Multiple spaces after hash on atx style heading", "tags": [ "headings", "atx", "spaces" ], + "parser": "markdownit", "function": function MD019(params, onError) { filterTokens(params, "heading_open", (token) => { if (headingStyleFor(token) === "atx") { @@ -49483,10 +53902,13 @@ module.exports = { const { addErrorContext, forEachLine } = __nccwpck_require__(2935); const { lineMetadata } = __nccwpck_require__(2260); +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD020", "no-missing-space-closed-atx" ], "description": "No space inside hashes on closed atx style heading", "tags": [ "headings", "atx_closed", "spaces" ], + "parser": "none", "function": function MD020(params, onError) { forEachLine(lineMetadata(), (line, lineIndex, inCode) => { if (!inCode) { @@ -49555,10 +53977,13 @@ const { addErrorContext, filterTokens, headingStyleFor } = const closedAtxRe = /^(#+)([ \t]+)([^ \t]|[^ \t].*[^ \t])([ \t]+)(#+)(\s*)$/; +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD021", "no-multiple-space-closed-atx" ], "description": "Multiple spaces inside hashes on closed atx style heading", "tags": [ "headings", "atx_closed", "spaces" ], + "parser": "markdownit", "function": function MD021(params, onError) { filterTokens(params, "heading_open", (token) => { if (headingStyleFor(token) === "atx_closed") { @@ -49649,16 +54074,24 @@ const getBlockQuote = (str, count) => ( .repeat(count) ); +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD022", "blanks-around-headings" ], "description": "Headings should be surrounded by blank lines", "tags": [ "headings", "blank_lines" ], + "parser": "micromark", "function": function MD022(params, onError) { const getLinesAbove = getLinesFunction(params.config.lines_above); const getLinesBelow = getLinesFunction(params.config.lines_below); - const { lines, parsers } = params; + // eslint-disable-next-line jsdoc/valid-types + /** @type import("../helpers/micromark.cjs").Token[] */ + const micromarkTokens = + // @ts-ignore + params.parsers.micromark.tokens; + const { lines } = params; const headings = filterByTypes( - parsers.micromark.tokens, + micromarkTokens, [ "atxHeading", "setextHeading" ] ).filter((heading) => !inHtmlFlow(heading)); for (const heading of headings) { @@ -49740,10 +54173,13 @@ const { addErrorContext, filterTokens } = __nccwpck_require__(2935); const spaceBeforeHeadingRe = /^(\s+|[>\s]+\s\s)[^>\s]/; +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD023", "heading-start-left" ], "description": "Headings must start at the beginning of the line", "tags": [ "headings", "spaces" ], + "parser": "markdownit", "function": function MD023(params, onError) { filterTokens(params, "heading_open", function forToken(token) { const { lineNumber, line } = token; @@ -49784,10 +54220,13 @@ module.exports = { const { addErrorContext, forEachHeading } = __nccwpck_require__(2935); +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD024", "no-duplicate-heading" ], "description": "Multiple headings with the same content", "tags": [ "headings" ], + "parser": "markdownit", "function": function MD024(params, onError) { const siblingsOnly = !!params.config.siblings_only || false; const knownContents = [ null, [] ]; @@ -49835,10 +54274,13 @@ module.exports = { const { addErrorContext, filterTokens, frontMatterHasTitle } = __nccwpck_require__(2935); +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD025", "single-title", "single-h1" ], "description": "Multiple top-level headings in the same document", "tags": [ "headings" ], + "parser": "markdownit", "function": function MD025(params, onError) { const level = Number(params.config.level || 1); const tag = "h" + level; @@ -49876,11 +54318,13 @@ const { addError, allPunctuationNoQuestion, endOfLineGemojiCodeRe, endOfLineHtmlEntityRe, escapeForRegExp } = __nccwpck_require__(2935); const { filterByTypes } = __nccwpck_require__(9901); - +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD026", "no-trailing-punctuation" ], "description": "Trailing punctuation in heading", "tags": [ "headings" ], + "parser": "micromark", "function": function MD026(params, onError) { let punctuation = params.config.punctuation; punctuation = String( @@ -49888,10 +54332,12 @@ module.exports = { ); const trailingPunctuationRe = new RegExp("\\s*[" + escapeForRegExp(punctuation) + "]+$"); - const headings = filterByTypes( - params.parsers.micromark.tokens, - [ "atxHeadingText", "setextHeadingText" ] - ); + // eslint-disable-next-line jsdoc/valid-types + /** @type import("../helpers/micromark.cjs").Token[] */ + const micromarkTokens = + // @ts-ignore + params.parsers.micromark.tokens; + const headings = filterByTypes(micromarkTokens, [ "atxHeadingText", "setextHeadingText" ]); for (const heading of headings) { const { endColumn, endLine, text } = heading; const match = trailingPunctuationRe.exec(text); @@ -49930,54 +54376,40 @@ module.exports = { -const { addErrorContext, newLineRe } = __nccwpck_require__(2935); - -const spaceAfterBlockQuoteRe = /^((?:\s*>)+)(\s{2,})\S/; +const { addErrorContext } = __nccwpck_require__(2935); +const { filterByTypes } = __nccwpck_require__(9901); +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { - "names": [ "MD027", "no-multiple-space-blockquote" ], + "names": ["MD027", "no-multiple-space-blockquote"], "description": "Multiple spaces after blockquote symbol", - "tags": [ "blockquote", "whitespace", "indentation" ], + "tags": ["blockquote", "whitespace", "indentation"], + "parser": "micromark", "function": function MD027(params, onError) { - let blockquoteNesting = 0; - let listItemNesting = 0; - for (const token of params.parsers.markdownit.tokens) { - const { content, lineNumber, type } = token; - if (type === "blockquote_open") { - blockquoteNesting++; - } else if (type === "blockquote_close") { - blockquoteNesting--; - } else if (type === "list_item_open") { - listItemNesting++; - } else if (type === "list_item_close") { - listItemNesting--; - } else if ((type === "inline") && blockquoteNesting) { - const lineCount = content.split(newLineRe).length; - for (let i = 0; i < lineCount; i++) { - const line = params.lines[lineNumber + i - 1]; - const match = line.match(spaceAfterBlockQuoteRe); - if (match) { - const [ - fullMatch, - { "length": blockquoteLength }, - { "length": spaceLength } - ] = match; - if (!listItemNesting || (fullMatch[fullMatch.length - 1] === ">")) { - addErrorContext( - onError, - lineNumber + i, - line, - null, - null, - [ 1, fullMatch.length ], - { - "editColumn": blockquoteLength + 1, - "deleteCount": spaceLength - 1 - } - ); - } + // eslint-disable-next-line jsdoc/valid-types + /** @type import("../helpers/micromark.cjs").Token[] */ + const micromarkTokens = + // @ts-ignore + params.parsers.micromark.tokens; + for (const token of filterByTypes(micromarkTokens, [ "linePrefix" ])) { + const siblings = token.parent?.children || micromarkTokens; + if (siblings[siblings.indexOf(token) - 1]?.type === "blockQuotePrefix") { + const { startColumn, startLine, text } = token; + const { length } = text; + const line = params.lines[startLine - 1]; + addErrorContext( + onError, + startLine, + line, + null, + null, + [ startColumn, length ], + { + "editColumn": startColumn, + "deleteCount": length } - } + ); } } } @@ -49995,28 +54427,45 @@ module.exports = { const { addError } = __nccwpck_require__(2935); +const { filterByTypes } = __nccwpck_require__(9901); +const ignoreTypes = new Set([ "lineEnding", "listItemIndent", "linePrefix" ]); + +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD028", "no-blanks-blockquote" ], "description": "Blank line inside blockquote", "tags": [ "blockquote", "whitespace" ], + "parser": "micromark", "function": function MD028(params, onError) { - let prevToken = {}; - let prevLineNumber = null; - for (const token of params.parsers.markdownit.tokens) { - if ((token.type === "blockquote_open") && - (prevToken.type === "blockquote_close")) { - for ( - let lineNumber = prevLineNumber; - lineNumber < token.lineNumber; - lineNumber++) { - addError(onError, lineNumber); + // eslint-disable-next-line jsdoc/valid-types + /** @type import("../helpers/micromark.cjs").Token[] */ + const micromarkTokens = + // @ts-ignore + params.parsers.micromark.tokens; + for (const token of filterByTypes(micromarkTokens, [ "blockQuote" ])) { + const errorLineNumbers = []; + const siblings = token.parent?.children || micromarkTokens; + for (let i = siblings.indexOf(token) + 1; i < siblings.length; i++) { + const sibling = siblings[i]; + const { startLine, type } = sibling; + if (type === "lineEndingBlank") { + // Possible blank between blockquotes + errorLineNumbers.push(startLine); + } else if (ignoreTypes.has(type)) { + // Ignore invisible formatting + } else if (type === "blockQuote") { + // Blockquote followed by blockquote + for (const lineNumber of errorLineNumbers) { + addError(onError, lineNumber); + } + break; + } else { + // Blockquote not followed by blockquote + break; } } - prevToken = token; - if (token.type === "blockquote_open") { - prevLineNumber = token.map[1] + 1; - } } } }; @@ -50042,10 +54491,13 @@ const listStyleExamples = { "zero": "0/0/0" }; +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD029", "ol-prefix" ], "description": "Ordered list item prefix", "tags": [ "ol" ], + "parser": "none", "function": function MD029(params, onError) { const style = String(params.config.style || "one_or_ordered"); const filteredLists = flattenedLists().filter((list) => !list.unordered); @@ -50110,19 +54562,24 @@ module.exports = { const { addErrorDetailIf } = __nccwpck_require__(2935); const { filterByTypes } = __nccwpck_require__(9901); +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD030", "list-marker-space" ], "description": "Spaces after list markers", "tags": [ "ol", "ul", "whitespace" ], + "parser": "micromark", "function": function MD030(params, onError) { const ulSingle = Number(params.config.ul_single || 1); const olSingle = Number(params.config.ol_single || 1); const ulMulti = Number(params.config.ul_multi || 1); const olMulti = Number(params.config.ol_multi || 1); - const lists = filterByTypes( - params.parsers.micromark.tokens, - [ "listOrdered", "listUnordered" ] - ); + // eslint-disable-next-line jsdoc/valid-types + /** @type import("../helpers/micromark.cjs").Token[] */ + const micromarkTokens = + // @ts-ignore + params.parsers.micromark.tokens; + const lists = filterByTypes(micromarkTokens, [ "listOrdered", "listUnordered" ]); for (const list of lists) { const ordered = (list.type === "listOrdered"); const listItemPrefixes = @@ -50181,10 +54638,13 @@ const { lineMetadata } = __nccwpck_require__(2260); const codeFencePrefixRe = /^(.*?)[`~]/; +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD031", "blanks-around-fences" ], "description": "Fenced code blocks should be surrounded by blank lines", "tags": [ "code", "blank_lines" ], + "parser": "none", "function": function MD031(params, onError) { const listItems = params.config.list_items; const includeListItems = (listItems === undefined) ? true : !!listItems; @@ -50224,19 +54684,9 @@ module.exports = { -const { addErrorContext, blockquotePrefixRe, isBlankLine } = - __nccwpck_require__(2935); -const { filterByPredicate } = __nccwpck_require__(9901); +const { addErrorContext, blockquotePrefixRe, isBlankLine } = __nccwpck_require__(2935); +const { filterByPredicate, nonContentTokens } = __nccwpck_require__(9901); -const nonContentTokens = new Set([ - "blockQuoteMarker", - "blockQuotePrefix", - "blockQuotePrefixWhitespace", - "lineEnding", - "lineEndingBlank", - "linePrefix", - "listItemIndent" -]); const isList = (token) => ( (token.type === "listOrdered") || (token.type === "listUnordered") ); @@ -50257,16 +54707,24 @@ const addBlankLineError = (onError, lines, lineIndex, lineNumber) => { ); }; +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD032", "blanks-around-lists" ], "description": "Lists should be surrounded by blank lines", "tags": [ "bullet", "ul", "ol", "blank_lines" ], + "parser": "micromark", "function": function MD032(params, onError) { - const { lines, parsers } = params; + // eslint-disable-next-line jsdoc/valid-types + /** @type import("../helpers/micromark.cjs").Token[] */ + const micromarkTokens = + // @ts-ignore + params.parsers.micromark.tokens; + const { lines } = params; // For every top-level list... const topLevelLists = filterByPredicate( - parsers.micromark.tokens, + micromarkTokens, isList, (token) => ( (isList(token) || (token.type === "htmlFlow")) ? [] : token.children @@ -50314,16 +54772,23 @@ const { addError, nextLinesRe } = __nccwpck_require__(2935); const { filterByTypes, getHtmlTagInfo } = __nccwpck_require__(9901); +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD033", "no-inline-html" ], "description": "Inline HTML", "tags": [ "html" ], + "parser": "micromark", "function": function MD033(params, onError) { let allowedElements = params.config.allowed_elements; allowedElements = Array.isArray(allowedElements) ? allowedElements : []; allowedElements = allowedElements.map((element) => element.toLowerCase()); - const { tokens } = params.parsers.micromark; - for (const token of filterByTypes(tokens, [ "htmlText" ])) { + // eslint-disable-next-line jsdoc/valid-types + /** @type import("../helpers/micromark.cjs").Token[] */ + const micromarkTokens = + // @ts-ignore + params.parsers.micromark.tokens; + for (const token of filterByTypes(micromarkTokens, [ "htmlText" ])) { const htmlTagInfo = getHtmlTagInfo(token); if ( htmlTagInfo && @@ -50361,15 +54826,44 @@ const { addErrorContext } = __nccwpck_require__(2935); const { filterByPredicate, filterByTypes, getHtmlTagInfo, inHtmlFlow, parse } = __nccwpck_require__(9901); +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD034", "no-bare-urls" ], "description": "Bare URL used", "tags": [ "links", "url" ], + "parser": "micromark", "function": function MD034(params, onError) { + // eslint-disable-next-line jsdoc/valid-types + /** @type import("../helpers/micromark.cjs").Token[] */ + const micromarkTokens = + // @ts-ignore + params.parsers.micromark.tokens; const literalAutolinks = (tokens) => ( filterByPredicate( tokens, - (token) => (token.type === "literalAutolink") && !inHtmlFlow(token), + (token) => { + if ((token.type === "literalAutolink") && !inHtmlFlow(token)) { + // Detect and ignore https://github.com/micromark/micromark/issues/164 + const siblings = token.parent?.children; + // Commented-out due to not being able to exercise in test/code coverage + // || micromarkTokens; + const index = siblings?.indexOf(token); + // @ts-ignore + const prev = siblings?.at(index - 1); + // @ts-ignore + const next = siblings?.at(index + 1); + return !( + prev && + next && + (prev.type === "data") && + (next.type === "data") && + prev.text.endsWith("<") && + next.text.startsWith(">") + ); + } + return false; + }, (token) => { const { children } = token; const result = []; @@ -50401,10 +54895,7 @@ module.exports = { } ) ); - const autoLinks = filterByTypes( - params.parsers.micromark.tokens, - [ "literalAutolink" ] - ); + const autoLinks = filterByTypes(micromarkTokens, [ "literalAutolink" ]); if (autoLinks.length > 0) { // Re-parse with correct link/image reference definition handling const document = params.lines.join("\n"); @@ -50447,14 +54938,21 @@ module.exports = { const { addErrorDetailIf } = __nccwpck_require__(2935); const { filterByTypes } = __nccwpck_require__(9901); +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD035", "hr-style" ], "description": "Horizontal rule style", "tags": [ "hr" ], + "parser": "micromark", "function": function MD035(params, onError) { let style = String(params.config.style || "consistent").trim(); - const thematicBreaks = - filterByTypes(params.parsers.micromark.tokens, [ "thematicBreak" ]); + // eslint-disable-next-line jsdoc/valid-types + /** @type import("../helpers/micromark.cjs").Token[] */ + const micromarkTokens = + // @ts-ignore + params.parsers.micromark.tokens; + const thematicBreaks = filterByTypes(micromarkTokens, [ "thematicBreak" ]); for (const token of thematicBreaks) { const { startLine, text } = token; if (style === "consistent") { @@ -50477,54 +54975,48 @@ module.exports = { const { addErrorContext, allPunctuation } = __nccwpck_require__(2935); +const { filterByTypes, matchAndGetTokensByType } = __nccwpck_require__(9901); +/** @typedef {import("../helpers/micromark.cjs").TokenType} TokenType */ +/** @type {Map} */ +const emphasisAndChildrenTypes = new Map([ + [ "emphasis", [ "emphasisSequence", "emphasisText", "emphasisSequence" ] ], + [ "strong", [ "strongSequence", "strongText", "strongSequence" ] ] +]); + +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD036", "no-emphasis-as-heading" ], "description": "Emphasis used instead of a heading", "tags": [ "headings", "emphasis" ], + "parser": "micromark", "function": function MD036(params, onError) { let punctuation = params.config.punctuation; - punctuation = - String((punctuation === undefined) ? allPunctuation : punctuation); - const re = new RegExp("[" + punctuation + "]$"); - // eslint-disable-next-line jsdoc/require-jsdoc - function base(token) { - if (token.type === "paragraph_open") { - return function inParagraph(t) { - // Always paragraph_open/inline/paragraph_close, - const children = t.children.filter(function notEmptyText(child) { - return (child.type !== "text") || (child.content !== ""); - }); - if ((children.length === 3) && - ((children[0].type === "strong_open") || - (children[0].type === "em_open")) && - (children[1].type === "text") && - !re.test(children[1].content)) { - addErrorContext(onError, t.lineNumber, - children[1].content); + punctuation = String((punctuation === undefined) ? allPunctuation : punctuation); + const punctuationRe = new RegExp("[" + punctuation + "]$"); + const paragraphTokens = + filterByTypes(params.parsers.micromark.tokens, [ "paragraph" ]). + filter((token) => + (token.parent?.type === "content") && !token.parent?.parent && (token.children.length === 1) + ); + for (const paragraphToken of paragraphTokens) { + const childToken = paragraphToken.children[0]; + for (const [ emphasisType, emphasisChildrenTypes ] of emphasisAndChildrenTypes) { + if (childToken.type === emphasisType) { + const matchingTokens = matchAndGetTokensByType(childToken.children, emphasisChildrenTypes); + if (matchingTokens) { + const textToken = matchingTokens[1]; + if ( + (textToken.children.length === 1) && + (textToken.children[0].type === "data") && + !punctuationRe.test(textToken.text) + ) { + addErrorContext(onError, textToken.startLine, textToken.text); + } } - return base; - }; - } else if (token.type === "blockquote_open") { - return function inBlockquote(t) { - if (t.type !== "blockquote_close") { - return inBlockquote; - } - return base; - }; - } else if (token.type === "list_item_open") { - return function inListItem(t) { - if (t.type !== "list_item_close") { - return inListItem; - } - return base; - }; + } } - return base; - } - let state = base; - for (const token of params.parsers.markdownit.tokens) { - state = state(token); } } }; @@ -50543,20 +55035,28 @@ module.exports = { const { addError } = __nccwpck_require__(2935); const { filterByPredicate, inHtmlFlow } = __nccwpck_require__(9901); +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD037", "no-space-in-emphasis" ], "description": "Spaces inside emphasis markers", "tags": [ "whitespace", "emphasis" ], + "parser": "micromark", "function": function MD037(params, onError) { // Initialize variables - const { lines, parsers } = params; + // eslint-disable-next-line jsdoc/valid-types + /** @type import("../helpers/micromark.cjs").Token[] */ + const micromarkTokens = + // @ts-ignore + params.parsers.micromark.tokens; + const { lines } = params; const emphasisTokensByMarker = new Map(); for (const marker of [ "_", "__", "___", "*", "**", "***" ]) { emphasisTokensByMarker.set(marker, []); } const tokens = filterByPredicate( - parsers.micromark.tokens, + micromarkTokens, (token) => token.children.some((child) => child.type === "data") ); for (const token of tokens) { @@ -50656,14 +55156,21 @@ const trimCodeText = (text, start, end) => { return text; }; +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD038", "no-space-in-code" ], "description": "Spaces inside code span elements", "tags": [ "whitespace", "code" ], + "parser": "micromark", "function": function MD038(params, onError) { - const codeTexts = - filterByTypes(params.parsers.micromark.tokens, [ "codeText" ]) - .filter((codeText) => !inHtmlFlow(codeText)); + // eslint-disable-next-line jsdoc/valid-types + /** @type import("../helpers/micromark.cjs").Token[] */ + const micromarkTokens = + // @ts-ignore + params.parsers.micromark.tokens; + const codeTexts = filterByTypes(micromarkTokens, [ "codeText" ]) + .filter((codeText) => !inHtmlFlow(codeText)); for (const codeText of codeTexts) { const { children } = codeText; const first = 0; @@ -50751,10 +55258,13 @@ const { addErrorContext, filterTokens } = __nccwpck_require__(2935); const spaceInLinkRe = /\[(?:\s[^\]]*|[^\]]*?\s)\](?=(\([^)]*\)|\[[^\]]*\]))/; +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD039", "no-space-in-links" ], "description": "Spaces inside link text", "tags": [ "whitespace", "links" ], + "parser": "markdownit", "function": function MD039(params, onError) { filterTokens(params, "inline", (token) => { const { children } = token; @@ -50777,6 +55287,7 @@ module.exports = { let fixInfo = null; const match = line.slice(lineIndex).match(spaceInLinkRe); if (match) { + // @ts-ignore const column = match.index + lineIndex + 1; const length = match[0].length; range = [ column, length ]; @@ -50821,37 +55332,42 @@ module.exports = { -const { addError, addErrorContext, filterTokens } = __nccwpck_require__(2935); +const { addError, addErrorContext } = __nccwpck_require__(2935); +const { filterByTypes, getTokenTextByType, tokenIfType } = + __nccwpck_require__(9901); +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD040", "fenced-code-language" ], "description": "Fenced code blocks should have a language specified", "tags": [ "code", "language" ], + "parser": "micromark", "function": function MD040(params, onError) { let allowed = params.config.allowed_languages; allowed = Array.isArray(allowed) ? allowed : []; const languageOnly = !!params.config.language_only; - - filterTokens(params, "fence", function forToken(token) { - const lang = token.info.trim().split(/\s+/u).shift(); - if (lang === "") { - addErrorContext(onError, token.lineNumber, token.line); - } else if ((allowed.length > 0) && !allowed.includes(lang)) { - addError( - onError, - token.lineNumber, - `"${lang}" is not allowed` - ); + // eslint-disable-next-line jsdoc/valid-types + /** @type import("../helpers/micromark.cjs").Token[] */ + const micromarkTokens = + // @ts-ignore + params.parsers.micromark.tokens; + const fencedCodes = filterByTypes(micromarkTokens, [ "codeFenced" ]); + for (const fencedCode of fencedCodes) { + const openingFence = tokenIfType(fencedCode.children[0], "codeFencedFence"); + if (openingFence) { + const { children, startLine, text } = openingFence; + const info = getTokenTextByType(children, "codeFencedFenceInfo"); + if (!info) { + addErrorContext(onError, startLine, text); + } else if ((allowed.length > 0) && !allowed.includes(info)) { + addError(onError, startLine, `"${info}" is not allowed`); + } + if (languageOnly && getTokenTextByType(children, "codeFencedFenceMeta")) { + addError(onError, startLine, `Info string contains more than language: "${text}"`); + } } - - if (languageOnly && (token.info !== lang)) { - addError( - onError, - token.lineNumber, - `Info string contains more than language: "${token.info}"` - ); - } - }); + } } }; @@ -50867,40 +55383,35 @@ module.exports = { const { addErrorContext, frontMatterHasTitle } = __nccwpck_require__(2935); +const { filterByTypes, getHeadingLevel, getHtmlTagInfo, isHtmlFlowComment, nonContentTokens } = + __nccwpck_require__(9901); +// eslint-disable-next-line jsdoc/valid-types +/** @type import("./markdownlint").Rule */ module.exports = { "names": [ "MD041", "first-line-heading", "first-line-h1" ], "description": "First line in a file should be a top-level heading", "tags": [ "headings" ], + "parser": "micromark", "function": function MD041(params, onError) { const level = Number(params.config.level || 1); - const tag = "h" + level; - const foundFrontMatterTitle = - frontMatterHasTitle( - params.frontMatterLines, - params.config.front_matter_title - ); - if (!foundFrontMatterTitle) { - const htmlHeadingRe = new RegExp(`^]`, "i"); - params.parsers.markdownit.tokens.every((token) => { - let isError = false; - if (token.type === "html_block") { - if (token.content.startsWith("