@fedify/fedify 1.6.0-dev.814 → 1.6.0-experiment.0

package/dist/node_modules/.pnpm/@jsr_std__yaml@1.0.6/node_modules/@jsr/std__yaml/_loader_state.js

@@ -0,0 +1,884 @@
+
+      import { Temporal } from "@js-temporal/polyfill";
+      import { URLPattern } from "urlpattern-polyfill";
+    
+import { AMPERSAND, ASTERISK, BACKSLASH, CARRIAGE_RETURN, COLON, COMMA, COMMERCIAL_AT, DOT, DOUBLE_QUOTE, EXCLAMATION, GRAVE_ACCENT, GREATER_THAN, LEFT_CURLY_BRACKET, LEFT_SQUARE_BRACKET, LINE_FEED, MINUS, PERCENT, PLUS, QUESTION, RIGHT_CURLY_BRACKET, RIGHT_SQUARE_BRACKET, SHARP, SINGLE_QUOTE, SMALLER_THAN, SPACE, VERTICAL_LINE, isEOL, isFlowIndicator, isWhiteSpace, isWhiteSpaceOrEOL } from "./_chars.js";
+import { isObject, isPlainObject } from "./_utils.js";
+import { DEFAULT_SCHEMA } from "./_schema.js";
+
+//#region node_modules/.pnpm/@jsr+std__yaml@1.0.6/node_modules/@jsr/std__yaml/_loader_state.js
+const CONTEXT_FLOW_IN = 1;
+const CONTEXT_FLOW_OUT = 2;
+const CONTEXT_BLOCK_IN = 3;
+const CONTEXT_BLOCK_OUT = 4;
+const CHOMPING_CLIP = 1;
+const CHOMPING_STRIP = 2;
+const CHOMPING_KEEP = 3;
+const PATTERN_NON_PRINTABLE = /[\x00-\x08\x0B\x0C\x0E-\x1F\x7F-\x84\x86-\x9F\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
+const PATTERN_NON_ASCII_LINE_BREAKS = /[\x85\u2028\u2029]/;
+const PATTERN_FLOW_INDICATORS = /[,\[\]\{\}]/;
+const PATTERN_TAG_HANDLE = /^(?:!|!!|![a-z\-]+!)$/i;
+const PATTERN_TAG_URI = /^(?:!|[^,\[\]\{\}])(?:%[0-9a-f]{2}|[0-9a-z\-#;\/\?:@&=\+\$,_\.!~\*'\(\)\[\]])*$/i;
+const ESCAPED_HEX_LENGTHS = new Map([
+	[120, 2],
+	[117, 4],
+	[85, 8]
+]);
+const SIMPLE_ESCAPE_SEQUENCES = new Map([
+	[48, "\0"],
+	[97, "\x07"],
+	[98, "\b"],
+	[116, "	"],
+	[9, "	"],
+	[110, "\n"],
+	[118, "\v"],
+	[102, "\f"],
+	[114, "\r"],
+	[101, "\x1B"],
+	[32, " "],
+	[34, "\""],
+	[47, "/"],
+	[92, "\\"],
+	[78, "…"],
+	[95, "\xA0"],
+	[76, "\u2028"],
+	[80, "\u2029"]
+]);
+/**
+* Converts a hexadecimal character code to its decimal value.
+*/ function hexCharCodeToNumber(charCode) {
+	if (48 <= charCode && charCode <= 57) return charCode - 48;
+	const lc = charCode | 32;
+	if (97 <= lc && lc <= 102) return lc - 97 + 10;
+	return -1;
+}
+/**
+* Converts a decimal character code to its decimal value.
+*/ function decimalCharCodeToNumber(charCode) {
+	if (48 <= charCode && charCode <= 57) return charCode - 48;
+	return -1;
+}
+/**
+* Converts a Unicode code point to a string.
+*/ function codepointToChar(codepoint) {
+	if (codepoint <= 65535) return String.fromCharCode(codepoint);
+	return String.fromCharCode((codepoint - 65536 >> 10) + 55296, (codepoint - 65536 & 1023) + 56320);
+}
+const INDENT = 4;
+const MAX_LENGTH = 75;
+const DELIMITERS = "\0\r\n…\u2028\u2029";
+function getSnippet(buffer, position) {
+	if (!buffer) return null;
+	let start = position;
+	let end = position;
+	let head = "";
+	let tail = "";
+	while (start > 0 && !DELIMITERS.includes(buffer.charAt(start - 1))) {
+		start--;
+		if (position - start > MAX_LENGTH / 2 - 1) {
+			head = " ... ";
+			start += 5;
+			break;
+		}
+	}
+	while (end < buffer.length && !DELIMITERS.includes(buffer.charAt(end))) {
+		end++;
+		if (end - position > MAX_LENGTH / 2 - 1) {
+			tail = " ... ";
+			end -= 5;
+			break;
+		}
+	}
+	const snippet = buffer.slice(start, end);
+	const indent = " ".repeat(INDENT);
+	const caretIndent = " ".repeat(INDENT + position - start + head.length);
+	return `${indent + head + snippet + tail}\n${caretIndent}^`;
+}
+function markToString(buffer, position, line, column) {
+	let where = `at line ${line + 1}, column ${column + 1}`;
+	const snippet = getSnippet(buffer, position);
+	if (snippet) where += `:\n${snippet}`;
+	return where;
+}
+var LoaderState = class {
+	input;
+	length;
+	lineIndent = 0;
+	lineStart = 0;
+	position = 0;
+	line = 0;
+	onWarning;
+	allowDuplicateKeys;
+	implicitTypes;
+	typeMap;
+	version;
+	checkLineBreaks = false;
+	tagMap = new Map();
+	anchorMap = new Map();
+	tag;
+	anchor;
+	kind;
+	result = "";
+	constructor(input, { schema = DEFAULT_SCHEMA, onWarning, allowDuplicateKeys = false }) {
+		this.input = input;
+		this.onWarning = onWarning;
+		this.allowDuplicateKeys = allowDuplicateKeys;
+		this.implicitTypes = schema.implicitTypes;
+		this.typeMap = schema.typeMap;
+		this.length = input.length;
+		this.version = null;
+		this.readIndent();
+	}
+	skipWhitespaces() {
+		let ch = this.peek();
+		while (isWhiteSpace(ch)) ch = this.next();
+	}
+	skipComment() {
+		let ch = this.peek();
+		if (ch !== SHARP) return;
+		ch = this.next();
+		while (ch !== 0 && !isEOL(ch)) ch = this.next();
+	}
+	readIndent() {
+		let char = this.peek();
+		while (char === SPACE) {
+			this.lineIndent += 1;
+			char = this.next();
+		}
+	}
+	peek(offset = 0) {
+		return this.input.charCodeAt(this.position + offset);
+	}
+	next() {
+		this.position += 1;
+		return this.peek();
+	}
+	#createError(message) {
+		const mark = markToString(this.input, this.position, this.line, this.position - this.lineStart);
+		return new SyntaxError(`${message} ${mark}`);
+	}
+	dispatchWarning(message) {
+		const error = this.#createError(message);
+		this.onWarning?.(error);
+	}
+	yamlDirectiveHandler(...args) {
+		if (this.version !== null) throw this.#createError("Cannot handle YAML directive: duplication of %YAML directive");
+		if (args.length !== 1) throw this.#createError("Cannot handle YAML directive: YAML directive accepts exactly one argument");
+		const match = /^([0-9]+)\.([0-9]+)$/.exec(args[0]);
+		if (match === null) throw this.#createError("Cannot handle YAML directive: ill-formed argument");
+		const major = parseInt(match[1], 10);
+		const minor = parseInt(match[2], 10);
+		if (major !== 1) throw this.#createError("Cannot handle YAML directive: unacceptable YAML version");
+		this.version = args[0] ?? null;
+		this.checkLineBreaks = minor < 2;
+		if (minor !== 1 && minor !== 2) return this.dispatchWarning("Cannot handle YAML directive: unsupported YAML version");
+	}
+	tagDirectiveHandler(...args) {
+		if (args.length !== 2) throw this.#createError(`Cannot handle tag directive: directive accepts exactly two arguments, received ${args.length}`);
+		const handle = args[0];
+		const prefix = args[1];
+		if (!PATTERN_TAG_HANDLE.test(handle)) throw this.#createError(`Cannot handle tag directive: ill-formed handle (first argument) in "${handle}"`);
+		if (this.tagMap.has(handle)) throw this.#createError(`Cannot handle tag directive: previously declared suffix for "${handle}" tag handle`);
+		if (!PATTERN_TAG_URI.test(prefix)) throw this.#createError("Cannot handle tag directive: ill-formed tag prefix (second argument) of the TAG directive");
+		this.tagMap.set(handle, prefix);
+	}
+	captureSegment(start, end, checkJson) {
+		if (start < end) {
+			const result = this.input.slice(start, end);
+			if (checkJson) for (let position = 0; position < result.length; position++) {
+				const character = result.charCodeAt(position);
+				if (!(character === 9 || 32 <= character && character <= 1114111)) throw this.#createError(`Expected valid JSON character: received "${character}"`);
+			}
+			else if (PATTERN_NON_PRINTABLE.test(result)) throw this.#createError("Stream contains non-printable characters");
+			this.result += result;
+		}
+	}
+	readBlockSequence(nodeIndent) {
+		let detected = false;
+		const tag = this.tag;
+		const anchor = this.anchor;
+		const result = [];
+		if (this.anchor !== null && typeof this.anchor !== "undefined") this.anchorMap.set(this.anchor, result);
+		let ch = this.peek();
+		while (ch !== 0) {
+			if (ch !== MINUS) break;
+			const following = this.peek(1);
+			if (!isWhiteSpaceOrEOL(following)) break;
+			detected = true;
+			this.position++;
+			if (this.skipSeparationSpace(true, -1)) {
+				if (this.lineIndent <= nodeIndent) {
+					result.push(null);
+					ch = this.peek();
+					continue;
+				}
+			}
+			const line = this.line;
+			this.composeNode(nodeIndent, CONTEXT_BLOCK_IN, false, true);
+			result.push(this.result);
+			this.skipSeparationSpace(true, -1);
+			ch = this.peek();
+			if ((this.line === line || this.lineIndent > nodeIndent) && ch !== 0) throw this.#createError("Cannot read block sequence: bad indentation of a sequence entry");
+			else if (this.lineIndent < nodeIndent) break;
+		}
+		if (detected) {
+			this.tag = tag;
+			this.anchor = anchor;
+			this.kind = "sequence";
+			this.result = result;
+			return true;
+		}
+		return false;
+	}
+	mergeMappings(destination, source, overridableKeys) {
+		if (!isObject(source)) throw this.#createError("Cannot merge mappings: the provided source object is unacceptable");
+		for (const [key, value] of Object.entries(source)) {
+			if (Object.hasOwn(destination, key)) continue;
+			Object.defineProperty(destination, key, {
+				value,
+				writable: true,
+				enumerable: true,
+				configurable: true
+			});
+			overridableKeys.add(key);
+		}
+	}
+	storeMappingPair(result, overridableKeys, keyTag, keyNode, valueNode, startLine, startPos) {
+		if (Array.isArray(keyNode)) {
+			keyNode = Array.prototype.slice.call(keyNode);
+			for (let index = 0; index < keyNode.length; index++) {
+				if (Array.isArray(keyNode[index])) throw this.#createError("Cannot store mapping pair: nested arrays are not supported inside keys");
+				if (typeof keyNode === "object" && isPlainObject(keyNode[index])) keyNode[index] = "[object Object]";
+			}
+		}
+		if (typeof keyNode === "object" && isPlainObject(keyNode)) keyNode = "[object Object]";
+		keyNode = String(keyNode);
+		if (keyTag === "tag:yaml.org,2002:merge") if (Array.isArray(valueNode)) for (let index = 0; index < valueNode.length; index++) this.mergeMappings(result, valueNode[index], overridableKeys);
+		else this.mergeMappings(result, valueNode, overridableKeys);
+		else {
+			if (!this.allowDuplicateKeys && !overridableKeys.has(keyNode) && Object.hasOwn(result, keyNode)) {
+				this.line = startLine || this.line;
+				this.position = startPos || this.position;
+				throw this.#createError("Cannot store mapping pair: duplicated key");
+			}
+			Object.defineProperty(result, keyNode, {
+				value: valueNode,
+				writable: true,
+				enumerable: true,
+				configurable: true
+			});
+			overridableKeys.delete(keyNode);
+		}
+		return result;
+	}
+	readLineBreak() {
+		const ch = this.peek();
+		if (ch === LINE_FEED) this.position++;
+		else if (ch === CARRIAGE_RETURN) {
+			this.position++;
+			if (this.peek() === LINE_FEED) this.position++;
+		} else throw this.#createError("Cannot read line: line break not found");
+		this.line += 1;
+		this.lineStart = this.position;
+	}
+	skipSeparationSpace(allowComments, checkIndent) {
+		let lineBreaks = 0;
+		let ch = this.peek();
+		while (ch !== 0) {
+			this.skipWhitespaces();
+			ch = this.peek();
+			if (allowComments) {
+				this.skipComment();
+				ch = this.peek();
+			}
+			if (isEOL(ch)) {
+				this.readLineBreak();
+				ch = this.peek();
+				lineBreaks++;
+				this.lineIndent = 0;
+				this.readIndent();
+				ch = this.peek();
+			} else break;
+		}
+		if (checkIndent !== -1 && lineBreaks !== 0 && this.lineIndent < checkIndent) this.dispatchWarning("deficient indentation");
+		return lineBreaks;
+	}
+	testDocumentSeparator() {
+		let ch = this.peek();
+		if ((ch === MINUS || ch === DOT) && ch === this.peek(1) && ch === this.peek(2)) {
+			ch = this.peek(3);
+			if (ch === 0 || isWhiteSpaceOrEOL(ch)) return true;
+		}
+		return false;
+	}
+	writeFoldedLines(count) {
+		if (count === 1) this.result += " ";
+		else if (count > 1) this.result += "\n".repeat(count - 1);
+	}
+	readPlainScalar(nodeIndent, withinFlowCollection) {
+		const kind = this.kind;
+		const result = this.result;
+		let ch = this.peek();
+		if (isWhiteSpaceOrEOL(ch) || isFlowIndicator(ch) || ch === SHARP || ch === AMPERSAND || ch === ASTERISK || ch === EXCLAMATION || ch === VERTICAL_LINE || ch === GREATER_THAN || ch === SINGLE_QUOTE || ch === DOUBLE_QUOTE || ch === PERCENT || ch === COMMERCIAL_AT || ch === GRAVE_ACCENT) return false;
+		let following;
+		if (ch === QUESTION || ch === MINUS) {
+			following = this.peek(1);
+			if (isWhiteSpaceOrEOL(following) || withinFlowCollection && isFlowIndicator(following)) return false;
+		}
+		this.kind = "scalar";
+		this.result = "";
+		let captureEnd = this.position;
+		let captureStart = this.position;
+		let hasPendingContent = false;
+		let line = 0;
+		while (ch !== 0) {
+			if (ch === COLON) {
+				following = this.peek(1);
+				if (isWhiteSpaceOrEOL(following) || withinFlowCollection && isFlowIndicator(following)) break;
+			} else if (ch === SHARP) {
+				const preceding = this.peek(-1);
+				if (isWhiteSpaceOrEOL(preceding)) break;
+			} else if (this.position === this.lineStart && this.testDocumentSeparator() || withinFlowCollection && isFlowIndicator(ch)) break;
+			else if (isEOL(ch)) {
+				line = this.line;
+				const lineStart = this.lineStart;
+				const lineIndent = this.lineIndent;
+				this.skipSeparationSpace(false, -1);
+				if (this.lineIndent >= nodeIndent) {
+					hasPendingContent = true;
+					ch = this.peek();
+					continue;
+				} else {
+					this.position = captureEnd;
+					this.line = line;
+					this.lineStart = lineStart;
+					this.lineIndent = lineIndent;
+					break;
+				}
+			}
+			if (hasPendingContent) {
+				this.captureSegment(captureStart, captureEnd, false);
+				this.writeFoldedLines(this.line - line);
+				captureStart = captureEnd = this.position;
+				hasPendingContent = false;
+			}
+			if (!isWhiteSpace(ch)) captureEnd = this.position + 1;
+			ch = this.next();
+		}
+		this.captureSegment(captureStart, captureEnd, false);
+		if (this.result) return true;
+		this.kind = kind;
+		this.result = result;
+		return false;
+	}
+	readSingleQuotedScalar(nodeIndent) {
+		let ch = this.peek();
+		if (ch !== SINGLE_QUOTE) return false;
+		this.kind = "scalar";
+		this.result = "";
+		this.position++;
+		let captureStart = this.position;
+		let captureEnd = this.position;
+		ch = this.peek();
+		while (ch !== 0) {
+			if (ch === SINGLE_QUOTE) {
+				this.captureSegment(captureStart, this.position, true);
+				ch = this.next();
+				if (ch === SINGLE_QUOTE) {
+					captureStart = this.position;
+					this.position++;
+					captureEnd = this.position;
+				} else return true;
+			} else if (isEOL(ch)) {
+				this.captureSegment(captureStart, captureEnd, true);
+				this.writeFoldedLines(this.skipSeparationSpace(false, nodeIndent));
+				captureStart = captureEnd = this.position;
+			} else if (this.position === this.lineStart && this.testDocumentSeparator()) throw this.#createError("Unexpected end of the document within a single quoted scalar");
+			else {
+				this.position++;
+				captureEnd = this.position;
+			}
+			ch = this.peek();
+		}
+		throw this.#createError("Unexpected end of the stream within a single quoted scalar");
+	}
+	readDoubleQuotedScalar(nodeIndent) {
+		let ch = this.peek();
+		if (ch !== DOUBLE_QUOTE) return false;
+		this.kind = "scalar";
+		this.result = "";
+		this.position++;
+		let captureEnd = this.position;
+		let captureStart = this.position;
+		let tmp;
+		ch = this.peek();
+		while (ch !== 0) {
+			if (ch === DOUBLE_QUOTE) {
+				this.captureSegment(captureStart, this.position, true);
+				this.position++;
+				return true;
+			}
+			if (ch === BACKSLASH) {
+				this.captureSegment(captureStart, this.position, true);
+				ch = this.next();
+				if (isEOL(ch)) this.skipSeparationSpace(false, nodeIndent);
+				else if (ch < 256 && SIMPLE_ESCAPE_SEQUENCES.has(ch)) {
+					this.result += SIMPLE_ESCAPE_SEQUENCES.get(ch);
+					this.position++;
+				} else if ((tmp = ESCAPED_HEX_LENGTHS.get(ch) ?? 0) > 0) {
+					let hexLength = tmp;
+					let hexResult = 0;
+					for (; hexLength > 0; hexLength--) {
+						ch = this.next();
+						if ((tmp = hexCharCodeToNumber(ch)) >= 0) hexResult = (hexResult << 4) + tmp;
+						else throw this.#createError("Cannot read double quoted scalar: expected hexadecimal character");
+					}
+					this.result += codepointToChar(hexResult);
+					this.position++;
+				} else throw this.#createError("Cannot read double quoted scalar: unknown escape sequence");
+				captureStart = captureEnd = this.position;
+			} else if (isEOL(ch)) {
+				this.captureSegment(captureStart, captureEnd, true);
+				this.writeFoldedLines(this.skipSeparationSpace(false, nodeIndent));
+				captureStart = captureEnd = this.position;
+			} else if (this.position === this.lineStart && this.testDocumentSeparator()) throw this.#createError("Unexpected end of the document within a double quoted scalar");
+			else {
+				this.position++;
+				captureEnd = this.position;
+			}
+			ch = this.peek();
+		}
+		throw this.#createError("Unexpected end of the stream within a double quoted scalar");
+	}
+	readFlowCollection(nodeIndent) {
+		let ch = this.peek();
+		let terminator;
+		let isMapping = true;
+		let result = {};
+		if (ch === LEFT_SQUARE_BRACKET) {
+			terminator = RIGHT_SQUARE_BRACKET;
+			isMapping = false;
+			result = [];
+		} else if (ch === LEFT_CURLY_BRACKET) terminator = RIGHT_CURLY_BRACKET;
+		else return false;
+		if (this.anchor !== null && typeof this.anchor !== "undefined") this.anchorMap.set(this.anchor, result);
+		ch = this.next();
+		const tag = this.tag;
+		const anchor = this.anchor;
+		let readNext = true;
+		let valueNode = null;
+		let keyNode = null;
+		let keyTag = null;
+		let isExplicitPair = false;
+		let isPair = false;
+		let following = 0;
+		let line = 0;
+		const overridableKeys = new Set();
+		while (ch !== 0) {
+			this.skipSeparationSpace(true, nodeIndent);
+			ch = this.peek();
+			if (ch === terminator) {
+				this.position++;
+				this.tag = tag;
+				this.anchor = anchor;
+				this.kind = isMapping ? "mapping" : "sequence";
+				this.result = result;
+				return true;
+			}
+			if (!readNext) throw this.#createError("Cannot read flow collection: missing comma between flow collection entries");
+			keyTag = keyNode = valueNode = null;
+			isPair = isExplicitPair = false;
+			if (ch === QUESTION) {
+				following = this.peek(1);
+				if (isWhiteSpaceOrEOL(following)) {
+					isPair = isExplicitPair = true;
+					this.position++;
+					this.skipSeparationSpace(true, nodeIndent);
+				}
+			}
+			line = this.line;
+			this.composeNode(nodeIndent, CONTEXT_FLOW_IN, false, true);
+			keyTag = this.tag || null;
+			keyNode = this.result;
+			this.skipSeparationSpace(true, nodeIndent);
+			ch = this.peek();
+			if ((isExplicitPair || this.line === line) && ch === COLON) {
+				isPair = true;
+				ch = this.next();
+				this.skipSeparationSpace(true, nodeIndent);
+				this.composeNode(nodeIndent, CONTEXT_FLOW_IN, false, true);
+				valueNode = this.result;
+			}
+			if (isMapping) this.storeMappingPair(result, overridableKeys, keyTag, keyNode, valueNode);
+			else if (isPair) result.push(this.storeMappingPair({}, overridableKeys, keyTag, keyNode, valueNode));
+			else result.push(keyNode);
+			this.skipSeparationSpace(true, nodeIndent);
+			ch = this.peek();
+			if (ch === COMMA) {
+				readNext = true;
+				ch = this.next();
+			} else readNext = false;
+		}
+		throw this.#createError("Cannot read flow collection: unexpected end of the stream within a flow collection");
+	}
+	readBlockScalar(nodeIndent) {
+		let chomping = CHOMPING_CLIP;
+		let didReadContent = false;
+		let detectedIndent = false;
+		let textIndent = nodeIndent;
+		let emptyLines = 0;
+		let atMoreIndented = false;
+		let ch = this.peek();
+		let folding = false;
+		if (ch === VERTICAL_LINE) folding = false;
+		else if (ch === GREATER_THAN) folding = true;
+		else return false;
+		this.kind = "scalar";
+		this.result = "";
+		let tmp = 0;
+		while (ch !== 0) {
+			ch = this.next();
+			if (ch === PLUS || ch === MINUS) if (CHOMPING_CLIP === chomping) chomping = ch === PLUS ? CHOMPING_KEEP : CHOMPING_STRIP;
+			else throw this.#createError("Cannot read block: chomping mode identifier repeated");
+			else if ((tmp = decimalCharCodeToNumber(ch)) >= 0) if (tmp === 0) throw this.#createError("Cannot read block: indentation width must be greater than 0");
+			else if (!detectedIndent) {
+				textIndent = nodeIndent + tmp - 1;
+				detectedIndent = true;
+			} else throw this.#createError("Cannot read block: indentation width identifier repeated");
+			else break;
+		}
+		if (isWhiteSpace(ch)) {
+			this.skipWhitespaces();
+			this.skipComment();
+			ch = this.peek();
+		}
+		while (ch !== 0) {
+			this.readLineBreak();
+			this.lineIndent = 0;
+			ch = this.peek();
+			while ((!detectedIndent || this.lineIndent < textIndent) && ch === SPACE) {
+				this.lineIndent++;
+				ch = this.next();
+			}
+			if (!detectedIndent && this.lineIndent > textIndent) textIndent = this.lineIndent;
+			if (isEOL(ch)) {
+				emptyLines++;
+				continue;
+			}
+			if (this.lineIndent < textIndent) {
+				if (chomping === CHOMPING_KEEP) this.result += "\n".repeat(didReadContent ? 1 + emptyLines : emptyLines);
+				else if (chomping === CHOMPING_CLIP) {
+					if (didReadContent) this.result += "\n";
+				}
+				break;
+			}
+			if (folding) if (isWhiteSpace(ch)) {
+				atMoreIndented = true;
+				this.result += "\n".repeat(didReadContent ? 1 + emptyLines : emptyLines);
+			} else if (atMoreIndented) {
+				atMoreIndented = false;
+				this.result += "\n".repeat(emptyLines + 1);
+			} else if (emptyLines === 0) {
+				if (didReadContent) this.result += " ";
+			} else this.result += "\n".repeat(emptyLines);
+			else this.result += "\n".repeat(didReadContent ? 1 + emptyLines : emptyLines);
+			didReadContent = true;
+			detectedIndent = true;
+			emptyLines = 0;
+			const captureStart = this.position;
+			while (!isEOL(ch) && ch !== 0) ch = this.next();
+			this.captureSegment(captureStart, this.position, false);
+		}
+		return true;
+	}
+	readBlockMapping(nodeIndent, flowIndent) {
+		const tag = this.tag;
+		const anchor = this.anchor;
+		const result = {};
+		const overridableKeys = new Set();
+		let allowCompact = false;
+		let line;
+		let pos;
+		let keyTag = null;
+		let keyNode = null;
+		let valueNode = null;
+		let atExplicitKey = false;
+		let detected = false;
+		if (this.anchor !== null && typeof this.anchor !== "undefined") this.anchorMap.set(this.anchor, result);
+		let ch = this.peek();
+		while (ch !== 0) {
+			const following = this.peek(1);
+			line = this.line;
+			pos = this.position;
+			if ((ch === QUESTION || ch === COLON) && isWhiteSpaceOrEOL(following)) {
+				if (ch === QUESTION) {
+					if (atExplicitKey) {
+						this.storeMappingPair(result, overridableKeys, keyTag, keyNode, null);
+						keyTag = null;
+						keyNode = null;
+						valueNode = null;
+					}
+					detected = true;
+					atExplicitKey = true;
+					allowCompact = true;
+				} else if (atExplicitKey) {
+					atExplicitKey = false;
+					allowCompact = true;
+				} else throw this.#createError("Cannot read block as explicit mapping pair is incomplete: a key node is missed or followed by a non-tabulated empty line");
+				this.position += 1;
+				ch = following;
+			} else if (this.composeNode(flowIndent, CONTEXT_FLOW_OUT, false, true)) if (this.line === line) {
+				ch = this.peek();
+				this.skipWhitespaces();
+				ch = this.peek();
+				if (ch === COLON) {
+					ch = this.next();
+					if (!isWhiteSpaceOrEOL(ch)) throw this.#createError("Cannot read block: a whitespace character is expected after the key-value separator within a block mapping");
+					if (atExplicitKey) {
+						this.storeMappingPair(result, overridableKeys, keyTag, keyNode, null);
+						keyTag = null;
+						keyNode = null;
+						valueNode = null;
+					}
+					detected = true;
+					atExplicitKey = false;
+					allowCompact = false;
+					keyTag = this.tag;
+					keyNode = this.result;
+				} else if (detected) throw this.#createError("Cannot read an implicit mapping pair: missing colon");
+				else {
+					this.tag = tag;
+					this.anchor = anchor;
+					return true;
+				}
+			} else if (detected) throw this.#createError("Cannot read a block mapping entry: a multiline key may not be an implicit key");
+			else {
+				this.tag = tag;
+				this.anchor = anchor;
+				return true;
+			}
+			else break;
+			if (this.line === line || this.lineIndent > nodeIndent) {
+				if (this.composeNode(nodeIndent, CONTEXT_BLOCK_OUT, true, allowCompact)) if (atExplicitKey) keyNode = this.result;
+				else valueNode = this.result;
+				if (!atExplicitKey) {
+					this.storeMappingPair(result, overridableKeys, keyTag, keyNode, valueNode, line, pos);
+					keyTag = keyNode = valueNode = null;
+				}
+				this.skipSeparationSpace(true, -1);
+				ch = this.peek();
+			}
+			if (this.lineIndent > nodeIndent && ch !== 0) throw this.#createError("Cannot read block: bad indentation of a mapping entry");
+			else if (this.lineIndent < nodeIndent) break;
+		}
+		if (atExplicitKey) this.storeMappingPair(result, overridableKeys, keyTag, keyNode, null);
+		if (detected) {
+			this.tag = tag;
+			this.anchor = anchor;
+			this.kind = "mapping";
+			this.result = result;
+		}
+		return detected;
+	}
+	readTagProperty() {
+		let isVerbatim = false;
+		let isNamed = false;
+		let tagHandle = "";
+		let tagName;
+		let ch = this.peek();
+		if (ch !== EXCLAMATION) return false;
+		if (this.tag !== null) throw this.#createError("Cannot read tag property: duplication of a tag property");
+		ch = this.next();
+		if (ch === SMALLER_THAN) {
+			isVerbatim = true;
+			ch = this.next();
+		} else if (ch === EXCLAMATION) {
+			isNamed = true;
+			tagHandle = "!!";
+			ch = this.next();
+		} else tagHandle = "!";
+		let position = this.position;
+		if (isVerbatim) {
+			do
+				ch = this.next();
+			while (ch !== 0 && ch !== GREATER_THAN);
+			if (this.position < this.length) {
+				tagName = this.input.slice(position, this.position);
+				ch = this.next();
+			} else throw this.#createError("Cannot read tag property: unexpected end of stream");
+		} else {
+			while (ch !== 0 && !isWhiteSpaceOrEOL(ch)) {
+				if (ch === EXCLAMATION) if (!isNamed) {
+					tagHandle = this.input.slice(position - 1, this.position + 1);
+					if (!PATTERN_TAG_HANDLE.test(tagHandle)) throw this.#createError("Cannot read tag property: named tag handle contains invalid characters");
+					isNamed = true;
+					position = this.position + 1;
+				} else throw this.#createError("Cannot read tag property: tag suffix cannot contain an exclamation mark");
+				ch = this.next();
+			}
+			tagName = this.input.slice(position, this.position);
+			if (PATTERN_FLOW_INDICATORS.test(tagName)) throw this.#createError("Cannot read tag property: tag suffix cannot contain flow indicator characters");
+		}
+		if (tagName && !PATTERN_TAG_URI.test(tagName)) throw this.#createError(`Cannot read tag property: invalid characters in tag name "${tagName}"`);
+		if (isVerbatim) this.tag = tagName;
+		else if (this.tagMap.has(tagHandle)) this.tag = this.tagMap.get(tagHandle) + tagName;
+		else if (tagHandle === "!") this.tag = `!${tagName}`;
+		else if (tagHandle === "!!") this.tag = `tag:yaml.org,2002:${tagName}`;
+		else throw this.#createError(`Cannot read tag property: undeclared tag handle "${tagHandle}"`);
+		return true;
+	}
+	readAnchorProperty() {
+		let ch = this.peek();
+		if (ch !== AMPERSAND) return false;
+		if (this.anchor !== null) throw this.#createError("Cannot read anchor property: duplicate anchor property");
+		ch = this.next();
+		const position = this.position;
+		while (ch !== 0 && !isWhiteSpaceOrEOL(ch) && !isFlowIndicator(ch)) ch = this.next();
+		if (this.position === position) throw this.#createError("Cannot read anchor property: name of an anchor node must contain at least one character");
+		this.anchor = this.input.slice(position, this.position);
+		return true;
+	}
+	readAlias() {
+		if (this.peek() !== ASTERISK) return false;
+		let ch = this.next();
+		const position = this.position;
+		while (ch !== 0 && !isWhiteSpaceOrEOL(ch) && !isFlowIndicator(ch)) ch = this.next();
+		if (this.position === position) throw this.#createError("Cannot read alias: alias name must contain at least one character");
+		const alias = this.input.slice(position, this.position);
+		if (!this.anchorMap.has(alias)) throw this.#createError(`Cannot read alias: unidentified alias "${alias}"`);
+		this.result = this.anchorMap.get(alias);
+		this.skipSeparationSpace(true, -1);
+		return true;
+	}
+	composeNode(parentIndent, nodeContext, allowToSeek, allowCompact) {
+		let indentStatus = 1;
+		let atNewLine = false;
+		let hasContent = false;
+		let type;
+		this.tag = null;
+		this.anchor = null;
+		this.kind = null;
+		this.result = null;
+		const allowBlockScalars = CONTEXT_BLOCK_OUT === nodeContext || CONTEXT_BLOCK_IN === nodeContext;
+		let allowBlockCollections = allowBlockScalars;
+		const allowBlockStyles = allowBlockScalars;
+		if (allowToSeek) {
+			if (this.skipSeparationSpace(true, -1)) {
+				atNewLine = true;
+				if (this.lineIndent > parentIndent) indentStatus = 1;
+				else if (this.lineIndent === parentIndent) indentStatus = 0;
+				else if (this.lineIndent < parentIndent) indentStatus = -1;
+			}
+		}
+		if (indentStatus === 1) while (this.readTagProperty() || this.readAnchorProperty()) if (this.skipSeparationSpace(true, -1)) {
+			atNewLine = true;
+			allowBlockCollections = allowBlockStyles;
+			if (this.lineIndent > parentIndent) indentStatus = 1;
+			else if (this.lineIndent === parentIndent) indentStatus = 0;
+			else if (this.lineIndent < parentIndent) indentStatus = -1;
+		} else allowBlockCollections = false;
+		if (allowBlockCollections) allowBlockCollections = atNewLine || allowCompact;
+		if (indentStatus === 1 || CONTEXT_BLOCK_OUT === nodeContext) {
+			const cond = CONTEXT_FLOW_IN === nodeContext || CONTEXT_FLOW_OUT === nodeContext;
+			const flowIndent = cond ? parentIndent : parentIndent + 1;
+			const blockIndent = this.position - this.lineStart;
+			if (indentStatus === 1) if (allowBlockCollections && (this.readBlockSequence(blockIndent) || this.readBlockMapping(blockIndent, flowIndent)) || this.readFlowCollection(flowIndent)) hasContent = true;
+			else {
+				if (allowBlockScalars && this.readBlockScalar(flowIndent) || this.readSingleQuotedScalar(flowIndent) || this.readDoubleQuotedScalar(flowIndent)) hasContent = true;
+				else if (this.readAlias()) {
+					hasContent = true;
+					if (this.tag !== null || this.anchor !== null) throw this.#createError("Cannot compose node: alias node should not have any properties");
+				} else if (this.readPlainScalar(flowIndent, CONTEXT_FLOW_IN === nodeContext)) {
+					hasContent = true;
+					if (this.tag === null) this.tag = "?";
+				}
+				if (this.anchor !== null) this.anchorMap.set(this.anchor, this.result);
+			}
+			else if (indentStatus === 0) hasContent = allowBlockCollections && this.readBlockSequence(blockIndent);
+		}
+		if (this.tag !== null && this.tag !== "!") if (this.tag === "?") for (let typeIndex = 0; typeIndex < this.implicitTypes.length; typeIndex++) {
+			type = this.implicitTypes[typeIndex];
+			if (type.resolve(this.result)) {
+				this.result = type.construct(this.result);
+				this.tag = type.tag;
+				if (this.anchor !== null) this.anchorMap.set(this.anchor, this.result);
+				break;
+			}
+		}
+		else if (this.typeMap[this.kind ?? "fallback"].has(this.tag)) {
+			const map = this.typeMap[this.kind ?? "fallback"];
+			type = map.get(this.tag);
+			if (this.result !== null && type.kind !== this.kind) throw this.#createError(`Unacceptable node kind for !<${this.tag}> tag: it should be "${type.kind}", not "${this.kind}"`);
+			if (!type.resolve(this.result)) throw this.#createError(`Cannot resolve a node with !<${this.tag}> explicit tag`);
+			else {
+				this.result = type.construct(this.result);
+				if (this.anchor !== null) this.anchorMap.set(this.anchor, this.result);
+			}
+		} else throw this.#createError(`Cannot resolve unknown tag !<${this.tag}>`);
+		return this.tag !== null || this.anchor !== null || hasContent;
+	}
+	readDocument() {
+		const documentStart = this.position;
+		let hasDirectives = false;
+		this.version = null;
+		this.checkLineBreaks = false;
+		this.tagMap = new Map();
+		this.anchorMap = new Map();
+		let ch = this.peek();
+		while (ch !== 0) {
+			this.skipSeparationSpace(true, -1);
+			ch = this.peek();
+			if (this.lineIndent > 0 || ch !== PERCENT) break;
+			hasDirectives = true;
+			ch = this.next();
+			let position = this.position;
+			while (ch !== 0 && !isWhiteSpaceOrEOL(ch)) ch = this.next();
+			const directiveName = this.input.slice(position, this.position);
+			const directiveArgs = [];
+			if (directiveName.length < 1) throw this.#createError("Cannot read document: directive name length must be greater than zero");
+			while (ch !== 0) {
+				this.skipWhitespaces();
+				this.skipComment();
+				ch = this.peek();
+				if (isEOL(ch)) break;
+				position = this.position;
+				while (ch !== 0 && !isWhiteSpaceOrEOL(ch)) ch = this.next();
+				directiveArgs.push(this.input.slice(position, this.position));
+			}
+			if (ch !== 0) this.readLineBreak();
+			switch (directiveName) {
+				case "YAML":
+					this.yamlDirectiveHandler(...directiveArgs);
+					break;
+				case "TAG":
+					this.tagDirectiveHandler(...directiveArgs);
+					break;
+				default:
+					this.dispatchWarning(`unknown document directive "${directiveName}"`);
+					break;
+			}
+			ch = this.peek();
+		}
+		this.skipSeparationSpace(true, -1);
+		if (this.lineIndent === 0 && this.peek() === MINUS && this.peek(1) === MINUS && this.peek(2) === MINUS) {
+			this.position += 3;
+			this.skipSeparationSpace(true, -1);
+		} else if (hasDirectives) throw this.#createError("Cannot read document: directives end mark is expected");
+		this.composeNode(this.lineIndent - 1, CONTEXT_BLOCK_OUT, false, true);
+		this.skipSeparationSpace(true, -1);
+		if (this.checkLineBreaks && PATTERN_NON_ASCII_LINE_BREAKS.test(this.input.slice(documentStart, this.position))) this.dispatchWarning("non-ASCII line breaks are interpreted as content");
+		if (this.position === this.lineStart && this.testDocumentSeparator()) {
+			if (this.peek() === DOT) {
+				this.position += 3;
+				this.skipSeparationSpace(true, -1);
+			}
+		} else if (this.position < this.length - 1) throw this.#createError("Cannot read document: end of the stream or a document separator is expected");
+		return this.result;
+	}
+	*readDocuments() {
+		while (this.position < this.length - 1) yield this.readDocument();
+	}
+};
+
+//#endregion
+export { LoaderState };