fumadocs-openapi 10.6.8 → 10.7.0

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/compose-scalar.js

@@ -0,0 +1,57 @@
+import { SCALAR, isScalar } from "../nodes/identity.js";
+import { Scalar } from "../nodes/Scalar.js";
+import { resolveBlockScalar } from "./resolve-block-scalar.js";
+import { resolveFlowScalar } from "./resolve-flow-scalar.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/compose-scalar.js
+function composeScalar(ctx, token, tagToken, onError) {
+	const { value, type, comment, range } = token.type === "block-scalar" ? resolveBlockScalar(ctx, token, onError) : 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[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[SCALAR];
+	let scalar;
+	try {
+		const res = tag.resolve(value, (msg) => onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg), ctx.options);
+		scalar = isScalar(res) ? res : new Scalar(res);
+	} catch (error) {
+		const msg = error instanceof Error ? error.message : String(error);
+		onError(tagToken ?? token, "TAG_RESOLVE_FAILED", msg);
+		scalar = new 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[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[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[SCALAR];
+	if (schema.compat) {
+		const compat = schema.compat.find((tag) => tag.default && tag.test?.test(value)) ?? schema[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;
+}
+//#endregion
+export { composeScalar };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/composer.js

@@ -0,0 +1,193 @@
+import { isCollection, isPair } from "../nodes/identity.js";
+import { Directives } from "../doc/directives.js";
+import { Document } from "../doc/Document.js";
+import { YAMLParseError, YAMLWarning } from "../errors.js";
+import { resolveEnd } from "./resolve-end.js";
+import { composeDoc } from "./compose-doc.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/composer.js
+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 YAMLWarning(pos, code, message));
+			else this.errors.push(new YAMLParseError(pos, code, message));
+		};
+		this.directives = new 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 (isCollection(dc) && !dc.flow && dc.items.length > 0) {
+				let it = dc.items[0];
+				if (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) {
+		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(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 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 YAMLParseError(getErrorPos(token), "UNEXPECTED_TOKEN", "Unexpected doc-end without preceding document"));
+					break;
+				}
+				this.doc.directives.docEnd = true;
+				const end = 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 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 doc = new Document(void 0, Object.assign({ _directives: this.directives }, this.options));
+			if (this.atDirectives) this.onError(endOffset, "MISSING_CHAR", "Missing directives-end indicator line");
+			doc.range = [
+				0,
+				endOffset,
+				endOffset
+			];
+			this.decorate(doc, false);
+			yield doc;
+		}
+	}
+};
+//#endregion
+export { Composer };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/resolve-block-map.js

@@ -0,0 +1,82 @@
+import { Pair } from "../nodes/Pair.js";
+import { YAMLMap } from "../nodes/YAMLMap.js";
+import { resolveProps } from "./resolve-props.js";
+import { containsNewline } from "./util-contains-newline.js";
+import { flowIndentCheck } from "./util-flow-indent-check.js";
+import { mapIncludes } from "./util-map-includes.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/resolve-block-map.js
+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)(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(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 || 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) flowIndentCheck(bm.indent, key, onError);
+		ctx.atKey = false;
+		if (mapIncludes(ctx, map.items, keyNode)) onError(keyStart, "DUPLICATE_KEY", "Map keys must be unique");
+		const valueProps = 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) flowIndentCheck(bm.indent, value, onError);
+			offset = valueNode.range[2];
+			const pair = new 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(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;
+}
+//#endregion
+export { resolveBlockMap };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/resolve-block-scalar.js

@@ -0,0 +1,173 @@
+import { Scalar } from "../nodes/Scalar.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/resolve-block-scalar.js
+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.BLOCK_FOLDED : 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.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;
+}
+//#endregion
+export { resolveBlockScalar };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/resolve-block-seq.js

@@ -0,0 +1,40 @@
+import { YAMLSeq } from "../nodes/YAMLSeq.js";
+import { resolveProps } from "./resolve-props.js";
+import { flowIndentCheck } from "./util-flow-indent-check.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/resolve-block-seq.js
+function resolveBlockSeq({ composeNode, composeEmptyNode }, ctx, bs, onError, tag) {
+	const seq = new (tag?.nodeClass ?? YAMLSeq)(ctx.schema);
+	if (ctx.atRoot) ctx.atRoot = false;
+	if (ctx.atKey) ctx.atKey = false;
+	let offset = bs.offset;
+	let commentEnd = null;
+	for (const { start, value } of bs.items) {
+		const props = resolveProps(start, {
+			indicator: "seq-item-ind",
+			next: value,
+			offset,
+			onError,
+			parentIndent: bs.indent,
+			startOnNewline: true
+		});
+		if (!props.found) if (props.anchor || props.tag || value) if (value?.type === "block-seq") onError(props.end, "BAD_INDENT", "All sequence items must start at the same column");
+		else onError(offset, "MISSING_CHAR", "Sequence item without - indicator");
+		else {
+			commentEnd = props.end;
+			if (props.comment) seq.comment = props.comment;
+			continue;
+		}
+		const node = value ? composeNode(ctx, value, props, onError) : composeEmptyNode(ctx, props.end, start, null, props, onError);
+		if (ctx.schema.compat) flowIndentCheck(bs.indent, value, onError);
+		offset = node.range[2];
+		seq.items.push(node);
+	}
+	seq.range = [
+		bs.offset,
+		offset,
+		commentEnd ?? offset
+	];
+	return seq;
+}
+//#endregion
+export { resolveBlockSeq };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/resolve-end.js

@@ -0,0 +1,36 @@
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/compose/resolve-end.js
+function resolveEnd(end, offset, reqSpace, onError) {
+	let comment = "";
+	if (end) {
+		let hasSpace = false;
+		let sep = "";
+		for (const token of end) {
+			const { source, type } = token;
+			switch (type) {
+				case "space":
+					hasSpace = true;
+					break;
+				case "comment": {
+					if (reqSpace && !hasSpace) onError(token, "MISSING_CHAR", "Comments must be separated from other tokens by white space characters");
+					const cb = source.substring(1) || " ";
+					if (!comment) comment = cb;
+					else comment += sep + cb;
+					sep = "";
+					break;
+				}
+				case "newline":
+					if (comment) sep += source;
+					hasSpace = true;
+					break;
+				default: onError(token, "UNEXPECTED_TOKEN", `Unexpected ${type} at node end`);
+			}
+			offset += source.length;
+		}
+	}
+	return {
+		comment,
+		offset
+	};
+}
+//#endregion
+export { resolveEnd };