cngpac 0.0.1

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/compose-node.mjs

@@ -0,0 +1,98 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "../nodes/identity.mjs";
+import { require_Alias } from "../nodes/Alias.mjs";
+import { require_resolve_end } from "./resolve-end.mjs";
+import { require_compose_collection } from "./compose-collection.mjs";
+import { require_compose_scalar } from "./compose-scalar.mjs";
+import { require_util_empty_scalar_position } from "./util-empty-scalar-position.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/compose-node.js
+var require_compose_node = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Alias = require_Alias();
+	var identity = require_identity();
+	var composeCollection = require_compose_collection();
+	var composeScalar = require_compose_scalar();
+	var resolveEnd = require_resolve_end();
+	var utilEmptyScalarPosition = require_util_empty_scalar_position();
+	const CN = {
+		composeNode,
+		composeEmptyNode
+	};
+	function composeNode(ctx, token, props, onError) {
+		const atKey = ctx.atKey;
+		const { spaceBefore, comment, anchor, tag } = props;
+		let node;
+		let isSrcToken = true;
+		switch (token.type) {
+			case "alias":
+				node = composeAlias(ctx, token, onError);
+				if (anchor || tag) onError(token, "ALIAS_PROPS", "An alias node must not specify any properties");
+				break;
+			case "scalar":
+			case "single-quoted-scalar":
+			case "double-quoted-scalar":
+			case "block-scalar":
+				node = composeScalar.composeScalar(ctx, token, tag, onError);
+				if (anchor) node.anchor = anchor.source.substring(1);
+				break;
+			case "block-map":
+			case "block-seq":
+			case "flow-collection":
+				try {
+					node = composeCollection.composeCollection(CN, ctx, token, props, onError);
+					if (anchor) node.anchor = anchor.source.substring(1);
+				} catch (error) {
+					onError(token, "RESOURCE_EXHAUSTION", error instanceof Error ? error.message : String(error));
+				}
+				break;
+			default:
+				onError(token, "UNEXPECTED_TOKEN", token.type === "error" ? token.message : `Unsupported token (type: ${token.type})`);
+				isSrcToken = false;
+		}
+		node ?? (node = composeEmptyNode(ctx, token.offset, void 0, null, props, onError));
+		if (anchor && node.anchor === "") onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string");
+		if (atKey && ctx.options.stringKeys && (!identity.isScalar(node) || typeof node.value !== "string" || node.tag && node.tag !== "tag:yaml.org,2002:str")) onError(tag ?? token, "NON_STRING_KEY", "With stringKeys, all keys must be strings");
+		if (spaceBefore) node.spaceBefore = true;
+		if (comment) if (token.type === "scalar" && token.source === "") node.comment = comment;
+		else node.commentBefore = comment;
+		if (ctx.options.keepSourceTokens && isSrcToken) node.srcToken = token;
+		return node;
+	}
+	function composeEmptyNode(ctx, offset, before, pos, { spaceBefore, comment, anchor, tag, end }, onError) {
+		const token = {
+			type: "scalar",
+			offset: utilEmptyScalarPosition.emptyScalarPosition(offset, before, pos),
+			indent: -1,
+			source: ""
+		};
+		const node = composeScalar.composeScalar(ctx, token, tag, onError);
+		if (anchor) {
+			node.anchor = anchor.source.substring(1);
+			if (node.anchor === "") onError(anchor, "BAD_ALIAS", "Anchor cannot be an empty string");
+		}
+		if (spaceBefore) node.spaceBefore = true;
+		if (comment) {
+			node.comment = comment;
+			node.range[2] = end;
+		}
+		return node;
+	}
+	function composeAlias({ options }, { offset, source, end }, onError) {
+		const alias = new Alias.Alias(source.substring(1));
+		if (alias.source === "") onError(offset, "BAD_ALIAS", "Alias cannot be an empty string");
+		if (alias.source.endsWith(":")) onError(offset + source.length - 1, "BAD_ALIAS", "Alias ending in : is ambiguous", true);
+		const valueEnd = offset + source.length;
+		const re = resolveEnd.resolveEnd(end, valueEnd, options.strict, onError);
+		alias.range = [
+			offset,
+			valueEnd,
+			re.offset
+		];
+		if (re.comment) alias.comment = re.comment;
+		return alias;
+	}
+	exports.composeEmptyNode = composeEmptyNode;
+	exports.composeNode = composeNode;
+}));
+//#endregion
+export default require_compose_node();
+export { require_compose_node };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/compose-scalar.mjs

@@ -0,0 +1,66 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "../nodes/identity.mjs";
+import { require_Scalar } from "../nodes/Scalar.mjs";
+import { require_resolve_block_scalar } from "./resolve-block-scalar.mjs";
+import { require_resolve_flow_scalar } from "./resolve-flow-scalar.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/compose-scalar.js
+var require_compose_scalar = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var identity = require_identity();
+	var Scalar = require_Scalar();
+	var resolveBlockScalar = require_resolve_block_scalar();
+	var resolveFlowScalar = require_resolve_flow_scalar();
+	function composeScalar(ctx, token, tagToken, onError) {
+		const { value, type, comment, range } = token.type === "block-scalar" ? resolveBlockScalar.resolveBlockScalar(ctx, token, onError) : resolveFlowScalar.resolveFlowScalar(token, ctx.options.strict, onError);
+		const tagName = tagToken ? ctx.directives.tagName(tagToken.source, (msg) => onError(tagToken, "TAG_RESOLVE_FAILED", msg)) : null;
+		let tag;
+		if (ctx.options.stringKeys && ctx.atKey) tag = ctx.schema[identity.SCALAR];
+		else if (tagName) tag = findScalarTagByName(ctx.schema, value, tagName, tagToken, onError);
+		else if (token.type === "scalar") tag = findScalarTagByTest(ctx, value, token, onError);
+		else tag = ctx.schema[identity.SCALAR];
+		let scalar;
+		try {
+			const res = tag.resolve(value, (msg) => onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg), ctx.options);
+			scalar = identity.isScalar(res) ? res : new Scalar.Scalar(res);
+		} catch (error) {
+			const msg = error instanceof Error ? error.message : String(error);
+			onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg);
+			scalar = new Scalar.Scalar(value);
+		}
+		scalar.range = range;
+		scalar.source = value;
+		if (type) scalar.type = type;
+		if (tagName) scalar.tag = tagName;
+		if (tag.format) scalar.format = tag.format;
+		if (comment) scalar.comment = comment;
+		return scalar;
+	}
+	function findScalarTagByName(schema, value, tagName, tagToken, onError) {
+		if (tagName === "!") return schema[identity.SCALAR];
+		const matchWithTest = [];
+		for (const tag of schema.tags) if (!tag.collection && tag.tag === tagName) if (tag.default && tag.test) matchWithTest.push(tag);
+		else return tag;
+		for (const tag of matchWithTest) if (tag.test?.test(value)) return tag;
+		const kt = schema.knownTags[tagName];
+		if (kt && !kt.collection) {
+			schema.tags.push(Object.assign({}, kt, {
+				default: false,
+				test: void 0
+			}));
+			return kt;
+		}
+		onError(tagToken, "TAG_RESOLVE_FAILED", `Unresolved tag: ${tagName}`, tagName !== "tag:yaml.org,2002:str");
+		return schema[identity.SCALAR];
+	}
+	function findScalarTagByTest({ atKey, directives, schema }, value, token, onError) {
+		const tag = schema.tags.find((tag) => (tag.default === true || atKey && tag.default === "key") && tag.test?.test(value)) || schema[identity.SCALAR];
+		if (schema.compat) {
+			const compat = schema.compat.find((tag) => tag.default && tag.test?.test(value)) ?? schema[identity.SCALAR];
+			if (tag.tag !== compat.tag) onError(token, "TAG_RESOLVE_FAILED", `Value may be parsed as either ${directives.tagString(tag.tag)} or ${directives.tagString(compat.tag)}`, true);
+		}
+		return tag;
+	}
+	exports.composeScalar = composeScalar;
+}));
+//#endregion
+export default require_compose_scalar();
+export { require_compose_scalar };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/composer.mjs

@@ -0,0 +1,207 @@
+import { __commonJSMin, __require } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_identity } from "../nodes/identity.mjs";
+import { require_directives } from "../doc/directives.mjs";
+import { require_Document } from "../doc/Document.mjs";
+import { require_errors } from "../errors.mjs";
+import { require_resolve_end } from "./resolve-end.mjs";
+import { require_compose_doc } from "./compose-doc.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/composer.js
+var require_composer = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var node_process = __require("process");
+	var directives = require_directives();
+	var Document = require_Document();
+	var errors = require_errors();
+	var identity = require_identity();
+	var composeDoc = require_compose_doc();
+	var resolveEnd = require_resolve_end();
+	function getErrorPos(src) {
+		if (typeof src === "number") return [src, src + 1];
+		if (Array.isArray(src)) return src.length === 2 ? src : [src[0], src[1]];
+		const { offset, source } = src;
+		return [offset, offset + (typeof source === "string" ? source.length : 1)];
+	}
+	function parsePrelude(prelude) {
+		let comment = "";
+		let atComment = false;
+		let afterEmptyLine = false;
+		for (let i = 0; i < prelude.length; ++i) {
+			const source = prelude[i];
+			switch (source[0]) {
+				case "#":
+					comment += (comment === "" ? "" : afterEmptyLine ? "\n\n" : "\n") + (source.substring(1) || " ");
+					atComment = true;
+					afterEmptyLine = false;
+					break;
+				case "%":
+					if (prelude[i + 1]?.[0] !== "#") i += 1;
+					atComment = false;
+					break;
+				default:
+					if (!atComment) afterEmptyLine = true;
+					atComment = false;
+			}
+		}
+		return {
+			comment,
+			afterEmptyLine
+		};
+	}
+	/**
+	* Compose a stream of CST nodes into a stream of YAML Documents.
+	*
+	* ```ts
+	* import { Composer, Parser } from 'yaml'
+	*
+	* const src: string = ...
+	* const tokens = new Parser().parse(src)
+	* const docs = new Composer().compose(tokens)
+	* ```
+	*/
+	var Composer = class {
+		constructor(options = {}) {
+			this.doc = null;
+			this.atDirectives = false;
+			this.prelude = [];
+			this.errors = [];
+			this.warnings = [];
+			this.onError = (source, code, message, warning) => {
+				const pos = getErrorPos(source);
+				if (warning) this.warnings.push(new errors.YAMLWarning(pos, code, message));
+				else this.errors.push(new errors.YAMLParseError(pos, code, message));
+			};
+			this.directives = new directives.Directives({ version: options.version || "1.2" });
+			this.options = options;
+		}
+		decorate(doc, afterDoc) {
+			const { comment, afterEmptyLine } = parsePrelude(this.prelude);
+			if (comment) {
+				const dc = doc.contents;
+				if (afterDoc) doc.comment = doc.comment ? `${doc.comment}\n${comment}` : comment;
+				else if (afterEmptyLine || doc.directives.docStart || !dc) doc.commentBefore = comment;
+				else if (identity.isCollection(dc) && !dc.flow && dc.items.length > 0) {
+					let it = dc.items[0];
+					if (identity.isPair(it)) it = it.key;
+					const cb = it.commentBefore;
+					it.commentBefore = cb ? `${comment}\n${cb}` : comment;
+				} else {
+					const cb = dc.commentBefore;
+					dc.commentBefore = cb ? `${comment}\n${cb}` : comment;
+				}
+			}
+			if (afterDoc) {
+				Array.prototype.push.apply(doc.errors, this.errors);
+				Array.prototype.push.apply(doc.warnings, this.warnings);
+			} else {
+				doc.errors = this.errors;
+				doc.warnings = this.warnings;
+			}
+			this.prelude = [];
+			this.errors = [];
+			this.warnings = [];
+		}
+		/**
+		* Current stream status information.
+		*
+		* Mostly useful at the end of input for an empty stream.
+		*/
+		streamInfo() {
+			return {
+				comment: parsePrelude(this.prelude).comment,
+				directives: this.directives,
+				errors: this.errors,
+				warnings: this.warnings
+			};
+		}
+		/**
+		* Compose tokens into documents.
+		*
+		* @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
+		* @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
+		*/
+		*compose(tokens, forceDoc = false, endOffset = -1) {
+			for (const token of tokens) yield* this.next(token);
+			yield* this.end(forceDoc, endOffset);
+		}
+		/** Advance the composer by one CST token. */
+		*next(token) {
+			if (node_process.env.LOG_STREAM) console.dir(token, { depth: null });
+			switch (token.type) {
+				case "directive":
+					this.directives.add(token.source, (offset, message, warning) => {
+						const pos = getErrorPos(token);
+						pos[0] += offset;
+						this.onError(pos, "BAD_DIRECTIVE", message, warning);
+					});
+					this.prelude.push(token.source);
+					this.atDirectives = true;
+					break;
+				case "document": {
+					const doc = composeDoc.composeDoc(this.options, this.directives, token, this.onError);
+					if (this.atDirectives && !doc.directives.docStart) this.onError(token, "MISSING_CHAR", "Missing directives-end/doc-start indicator line");
+					this.decorate(doc, false);
+					if (this.doc) yield this.doc;
+					this.doc = doc;
+					this.atDirectives = false;
+					break;
+				}
+				case "byte-order-mark":
+				case "space": break;
+				case "comment":
+				case "newline":
+					this.prelude.push(token.source);
+					break;
+				case "error": {
+					const msg = token.source ? `${token.message}: ${JSON.stringify(token.source)}` : token.message;
+					const error = new errors.YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", msg);
+					if (this.atDirectives || !this.doc) this.errors.push(error);
+					else this.doc.errors.push(error);
+					break;
+				}
+				case "doc-end": {
+					if (!this.doc) {
+						this.errors.push(new errors.YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", "Unexpected doc-end without preceding document"));
+						break;
+					}
+					this.doc.directives.docEnd = true;
+					const end = resolveEnd.resolveEnd(token.end, token.offset + token.source.length, this.doc.options.strict, this.onError);
+					this.decorate(this.doc, true);
+					if (end.comment) {
+						const dc = this.doc.comment;
+						this.doc.comment = dc ? `${dc}\n${end.comment}` : end.comment;
+					}
+					this.doc.range[2] = end.offset;
+					break;
+				}
+				default: this.errors.push(new errors.YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", `Unsupported token ${token.type}`));
+			}
+		}
+		/**
+		* Call at end of input to yield any remaining document.
+		*
+		* @param forceDoc - If the stream contains no document, still emit a final document including any comments and directives that would be applied to a subsequent document.
+		* @param endOffset - Should be set if `forceDoc` is also set, to set the document range end and to indicate errors correctly.
+		*/
+		*end(forceDoc = false, endOffset = -1) {
+			if (this.doc) {
+				this.decorate(this.doc, true);
+				yield this.doc;
+				this.doc = null;
+			} else if (forceDoc) {
+				const opts = Object.assign({ _directives: this.directives }, this.options);
+				const doc = new Document.Document(void 0, opts);
+				if (this.atDirectives) this.onError(endOffset, "MISSING_CHAR", "Missing directives-end indicator line");
+				doc.range = [
+					0,
+					endOffset,
+					endOffset
+				];
+				this.decorate(doc, false);
+				yield doc;
+			}
+		}
+	};
+	exports.Composer = Composer;
+}));
+//#endregion
+export default require_composer();
+export { require_composer };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/resolve-block-map.mjs

@@ -0,0 +1,93 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_Pair } from "../nodes/Pair.mjs";
+import { require_YAMLMap } from "../nodes/YAMLMap.mjs";
+import { require_resolve_props } from "./resolve-props.mjs";
+import { require_util_contains_newline } from "./util-contains-newline.mjs";
+import { require_util_flow_indent_check } from "./util-flow-indent-check.mjs";
+import { require_util_map_includes } from "./util-map-includes.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/resolve-block-map.js
+var require_resolve_block_map = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Pair = require_Pair();
+	var YAMLMap = require_YAMLMap();
+	var resolveProps = require_resolve_props();
+	var utilContainsNewline = require_util_contains_newline();
+	var utilFlowIndentCheck = require_util_flow_indent_check();
+	var utilMapIncludes = require_util_map_includes();
+	const startColMsg = "All mapping items must start at the same column";
+	function resolveBlockMap({ composeNode, composeEmptyNode }, ctx, bm, onError, tag) {
+		const map = new (tag?.nodeClass ?? YAMLMap.YAMLMap)(ctx.schema);
+		if (ctx.atRoot) ctx.atRoot = false;
+		let offset = bm.offset;
+		let commentEnd = null;
+		for (const collItem of bm.items) {
+			const { start, key, sep, value } = collItem;
+			const keyProps = resolveProps.resolveProps(start, {
+				indicator: "explicit-key-ind",
+				next: key ?? sep?.[0],
+				offset,
+				onError,
+				parentIndent: bm.indent,
+				startOnNewline: true
+			});
+			const implicitKey = !keyProps.found;
+			if (implicitKey) {
+				if (key) {
+					if (key.type === "block-seq") onError(offset, "BLOCK_AS_IMPLICIT_KEY", "A block sequence may not be used as an implicit map key");
+					else if ("indent" in key && key.indent !== bm.indent) onError(offset, "BAD_INDENT", startColMsg);
+				}
+				if (!keyProps.anchor && !keyProps.tag && !sep) {
+					commentEnd = keyProps.end;
+					if (keyProps.comment) if (map.comment) map.comment += "\n" + keyProps.comment;
+					else map.comment = keyProps.comment;
+					continue;
+				}
+				if (keyProps.newlineAfterProp || utilContainsNewline.containsNewline(key)) onError(key ?? start[start.length - 1], "MULTILINE_IMPLICIT_KEY", "Implicit keys need to be on a single line");
+			} else if (keyProps.found?.indent !== bm.indent) onError(offset, "BAD_INDENT", startColMsg);
+			ctx.atKey = true;
+			const keyStart = keyProps.end;
+			const keyNode = key ? composeNode(ctx, key, keyProps, onError) : composeEmptyNode(ctx, keyStart, start, null, keyProps, onError);
+			if (ctx.schema.compat) utilFlowIndentCheck.flowIndentCheck(bm.indent, key, onError);
+			ctx.atKey = false;
+			if (utilMapIncludes.mapIncludes(ctx, map.items, keyNode)) onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
+			const valueProps = resolveProps.resolveProps(sep ?? [], {
+				indicator: "map-value-ind",
+				next: value,
+				offset: keyNode.range[2],
+				onError,
+				parentIndent: bm.indent,
+				startOnNewline: !key || key.type === "block-scalar"
+			});
+			offset = valueProps.end;
+			if (valueProps.found) {
+				if (implicitKey) {
+					if (value?.type === "block-map" && !valueProps.hasNewline) onError(offset, "BLOCK_AS_IMPLICIT_KEY", "Nested mappings are not allowed in compact mappings");
+					if (ctx.options.strict && keyProps.start < valueProps.found.offset - 1024) onError(keyNode.range, "KEY_OVER_1024_CHARS", "The : indicator must be at most 1024 chars after the start of an implicit block mapping key");
+				}
+				const valueNode = value ? composeNode(ctx, value, valueProps, onError) : composeEmptyNode(ctx, offset, sep, null, valueProps, onError);
+				if (ctx.schema.compat) utilFlowIndentCheck.flowIndentCheck(bm.indent, value, onError);
+				offset = valueNode.range[2];
+				const pair = new Pair.Pair(keyNode, valueNode);
+				if (ctx.options.keepSourceTokens) pair.srcToken = collItem;
+				map.items.push(pair);
+			} else {
+				if (implicitKey) onError(keyNode.range, "MISSING_CHAR", "Implicit map keys need to be followed by map values");
+				if (valueProps.comment) if (keyNode.comment) keyNode.comment += "\n" + valueProps.comment;
+				else keyNode.comment = valueProps.comment;
+				const pair = new Pair.Pair(keyNode);
+				if (ctx.options.keepSourceTokens) pair.srcToken = collItem;
+				map.items.push(pair);
+			}
+		}
+		if (commentEnd && commentEnd < offset) onError(commentEnd, "IMPOSSIBLE", "Map comment with trailing content");
+		map.range = [
+			bm.offset,
+			offset,
+			commentEnd ?? offset
+		];
+		return map;
+	}
+	exports.resolveBlockMap = resolveBlockMap;
+}));
+//#endregion
+export default require_resolve_block_map();
+export { require_resolve_block_map };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/resolve-block-scalar.mjs

@@ -0,0 +1,179 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_Scalar } from "../nodes/Scalar.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/compose/resolve-block-scalar.js
+var require_resolve_block_scalar = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Scalar = require_Scalar();
+	function resolveBlockScalar(ctx, scalar, onError) {
+		const start = scalar.offset;
+		const header = parseBlockScalarHeader(scalar, ctx.options.strict, onError);
+		if (!header) return {
+			value: "",
+			type: null,
+			comment: "",
+			range: [
+				start,
+				start,
+				start
+			]
+		};
+		const type = header.mode === ">" ? Scalar.Scalar.BLOCK_FOLDED : Scalar.Scalar.BLOCK_LITERAL;
+		const lines = scalar.source ? splitLines(scalar.source) : [];
+		let chompStart = lines.length;
+		for (let i = lines.length - 1; i >= 0; --i) {
+			const content = lines[i][1];
+			if (content === "" || content === "\r") chompStart = i;
+			else break;
+		}
+		if (chompStart === 0) {
+			const value = header.chomp === "+" && lines.length > 0 ? "\n".repeat(Math.max(1, lines.length - 1)) : "";
+			let end = start + header.length;
+			if (scalar.source) end += scalar.source.length;
+			return {
+				value,
+				type,
+				comment: header.comment,
+				range: [
+					start,
+					end,
+					end
+				]
+			};
+		}
+		let trimIndent = scalar.indent + header.indent;
+		let offset = scalar.offset + header.length;
+		let contentStart = 0;
+		for (let i = 0; i < chompStart; ++i) {
+			const [indent, content] = lines[i];
+			if (content === "" || content === "\r") {
+				if (header.indent === 0 && indent.length > trimIndent) trimIndent = indent.length;
+			} else {
+				if (indent.length < trimIndent) onError(offset + indent.length, "MISSING_CHAR", "Block scalars with more-indented leading empty lines must use an explicit indentation indicator");
+				if (header.indent === 0) trimIndent = indent.length;
+				contentStart = i;
+				if (trimIndent === 0 && !ctx.atRoot) onError(offset, "BAD_INDENT", "Block scalar values in collections must be indented");
+				break;
+			}
+			offset += indent.length + content.length + 1;
+		}
+		for (let i = lines.length - 1; i >= chompStart; --i) if (lines[i][0].length > trimIndent) chompStart = i + 1;
+		let value = "";
+		let sep = "";
+		let prevMoreIndented = false;
+		for (let i = 0; i < contentStart; ++i) value += lines[i][0].slice(trimIndent) + "\n";
+		for (let i = contentStart; i < chompStart; ++i) {
+			let [indent, content] = lines[i];
+			offset += indent.length + content.length + 1;
+			const crlf = content[content.length - 1] === "\r";
+			if (crlf) content = content.slice(0, -1);
+			/* istanbul ignore if already caught in lexer */
+			if (content && indent.length < trimIndent) {
+				const message = `Block scalar lines must not be less indented than their ${header.indent ? "explicit indentation indicator" : "first line"}`;
+				onError(offset - content.length - (crlf ? 2 : 1), "BAD_INDENT", message);
+				indent = "";
+			}
+			if (type === Scalar.Scalar.BLOCK_LITERAL) {
+				value += sep + indent.slice(trimIndent) + content;
+				sep = "\n";
+			} else if (indent.length > trimIndent || content[0] === "	") {
+				if (sep === " ") sep = "\n";
+				else if (!prevMoreIndented && sep === "\n") sep = "\n\n";
+				value += sep + indent.slice(trimIndent) + content;
+				sep = "\n";
+				prevMoreIndented = true;
+			} else if (content === "") if (sep === "\n") value += "\n";
+			else sep = "\n";
+			else {
+				value += sep + content;
+				sep = " ";
+				prevMoreIndented = false;
+			}
+		}
+		switch (header.chomp) {
+			case "-": break;
+			case "+":
+				for (let i = chompStart; i < lines.length; ++i) value += "\n" + lines[i][0].slice(trimIndent);
+				if (value[value.length - 1] !== "\n") value += "\n";
+				break;
+			default: value += "\n";
+		}
+		const end = start + header.length + scalar.source.length;
+		return {
+			value,
+			type,
+			comment: header.comment,
+			range: [
+				start,
+				end,
+				end
+			]
+		};
+	}
+	function parseBlockScalarHeader({ offset, props }, strict, onError) {
+		/* istanbul ignore if should not happen */
+		if (props[0].type !== "block-scalar-header") {
+			onError(props[0], "IMPOSSIBLE", "Block scalar header not found");
+			return null;
+		}
+		const { source } = props[0];
+		const mode = source[0];
+		let indent = 0;
+		let chomp = "";
+		let error = -1;
+		for (let i = 1; i < source.length; ++i) {
+			const ch = source[i];
+			if (!chomp && (ch === "-" || ch === "+")) chomp = ch;
+			else {
+				const n = Number(ch);
+				if (!indent && n) indent = n;
+				else if (error === -1) error = offset + i;
+			}
+		}
+		if (error !== -1) onError(error, "UNEXPECTED_TOKEN", `Block scalar header includes extra characters: ${source}`);
+		let hasSpace = false;
+		let comment = "";
+		let length = source.length;
+		for (let i = 1; i < props.length; ++i) {
+			const token = props[i];
+			switch (token.type) {
+				case "space": hasSpace = true;
+				case "newline":
+					length += token.source.length;
+					break;
+				case "comment":
+					if (strict && !hasSpace) onError(token, "MISSING_CHAR", "Comments must be separated from other tokens by white space characters");
+					length += token.source.length;
+					comment = token.source.substring(1);
+					break;
+				case "error":
+					onError(token, "UNEXPECTED_TOKEN", token.message);
+					length += token.source.length;
+					break;
+				default: {
+					onError(token, "UNEXPECTED_TOKEN", `Unexpected token in block scalar header: ${token.type}`);
+					const ts = token.source;
+					if (ts && typeof ts === "string") length += ts.length;
+				}
+			}
+		}
+		return {
+			mode,
+			indent,
+			chomp,
+			comment,
+			length
+		};
+	}
+	/** @returns Array of lines split up as `[indent, content]` */
+	function splitLines(source) {
+		const split = source.split(/\n( *)/);
+		const first = split[0];
+		const m = first.match(/^( *)/);
+		const lines = [m?.[1] ? [m[1], first.slice(m[1].length)] : ["", first]];
+		for (let i = 1; i < split.length; i += 2) lines.push([split[i], split[i + 1]]);
+		return lines;
+	}
+	exports.resolveBlockScalar = resolveBlockScalar;
+}));
+//#endregion
+export default require_resolve_block_scalar();
+export { require_resolve_block_scalar };