fumadocs-openapi 10.6.8 → 10.7.0

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/parse/cst-visit.js

@@ -0,0 +1,89 @@
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/parse/cst-visit.js
+const BREAK = Symbol("break visit");
+const SKIP = Symbol("skip children");
+const REMOVE = Symbol("remove item");
+/**
+* Apply a visitor to a CST document or item.
+*
+* Walks through the tree (depth-first) starting from the root, calling a
+* `visitor` function with two arguments when entering each item:
+*   - `item`: The current item, which included the following members:
+*     - `start: SourceToken[]` – Source tokens before the key or value,
+*       possibly including its anchor or tag.
+*     - `key?: Token | null` – Set for pair values. May then be `null`, if
+*       the key before the `:` separator is empty.
+*     - `sep?: SourceToken[]` – Source tokens between the key and the value,
+*       which should include the `:` map value indicator if `value` is set.
+*     - `value?: Token` – The value of a sequence item, or of a map pair.
+*   - `path`: The steps from the root to the current node, as an array of
+*     `['key' | 'value', number]` tuples.
+*
+* The return value of the visitor may be used to control the traversal:
+*   - `undefined` (default): Do nothing and continue
+*   - `visit.SKIP`: Do not visit the children of this token, continue with
+*      next sibling
+*   - `visit.BREAK`: Terminate traversal completely
+*   - `visit.REMOVE`: Remove the current item, then continue with the next one
+*   - `number`: Set the index of the next step. This is useful especially if
+*     the index of the current token has changed.
+*   - `function`: Define the next visitor for this item. After the original
+*     visitor is called on item entry, next visitors are called after handling
+*     a non-empty `key` and when exiting the item.
+*/
+function visit(cst, visitor) {
+	if ("type" in cst && cst.type === "document") cst = {
+		start: cst.start,
+		value: cst.value
+	};
+	_visit(Object.freeze([]), cst, visitor);
+}
+/** Terminate visit traversal completely */
+visit.BREAK = BREAK;
+/** Do not visit the children of the current item */
+visit.SKIP = SKIP;
+/** Remove the current item */
+visit.REMOVE = REMOVE;
+/** Find the item at `path` from `cst` as the root */
+visit.itemAtPath = (cst, path) => {
+	let item = cst;
+	for (const [field, index] of path) {
+		const tok = item?.[field];
+		if (tok && "items" in tok) item = tok.items[index];
+		else return void 0;
+	}
+	return item;
+};
+/**
+* Get the immediate parent collection of the item at `path` from `cst` as the root.
+*
+* Throws an error if the collection is not found, which should never happen if the item itself exists.
+*/
+visit.parentCollection = (cst, path) => {
+	const parent = visit.itemAtPath(cst, path.slice(0, -1));
+	const field = path[path.length - 1][0];
+	const coll = parent?.[field];
+	if (coll && "items" in coll) return coll;
+	throw new Error("Parent collection not found");
+};
+function _visit(path, item, visitor) {
+	let ctrl = visitor(item, path);
+	if (typeof ctrl === "symbol") return ctrl;
+	for (const field of ["key", "value"]) {
+		const token = item[field];
+		if (token && "items" in token) {
+			for (let i = 0; i < token.items.length; ++i) {
+				const ci = _visit(Object.freeze(path.concat([[field, i]])), token.items[i], visitor);
+				if (typeof ci === "number") i = ci - 1;
+				else if (ci === BREAK) return BREAK;
+				else if (ci === REMOVE) {
+					token.items.splice(i, 1);
+					i -= 1;
+				}
+			}
+			if (typeof ctrl === "function" && field === "key") ctrl = ctrl(item, path);
+		}
+	}
+	return typeof ctrl === "function" ? ctrl(item, path) : ctrl;
+}
+//#endregion
+export { visit };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/parse/cst.js

@@ -0,0 +1,40 @@
+import "./cst-scalar.js";
+import "./cst-visit.js";
+/** Identify the type of a lexer token. May return `null` for unknown tokens. */
+function tokenType(source) {
+	switch (source) {
+		case "": return "byte-order-mark";
+		case "": return "doc-mode";
+		case "": return "flow-error-end";
+		case "": return "scalar";
+		case "---": return "doc-start";
+		case "...": return "doc-end";
+		case "":
+		case "\n":
+		case "\r\n": return "newline";
+		case "-": return "seq-item-ind";
+		case "?": return "explicit-key-ind";
+		case ":": return "map-value-ind";
+		case "{": return "flow-map-start";
+		case "}": return "flow-map-end";
+		case "[": return "flow-seq-start";
+		case "]": return "flow-seq-end";
+		case ",": return "comma";
+	}
+	switch (source[0]) {
+		case " ":
+		case "	": return "space";
+		case "#": return "comment";
+		case "%": return "directive-line";
+		case "*": return "alias";
+		case "&": return "anchor";
+		case "!": return "tag";
+		case "'": return "single-quoted-scalar";
+		case "\"": return "double-quoted-scalar";
+		case "|":
+		case ">": return "block-scalar-header";
+	}
+	return null;
+}
+//#endregion
+export { tokenType };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/parse/lexer.js

@@ -0,0 +1,517 @@
+import "./cst.js";
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/parse/lexer.js
+function isEmpty(ch) {
+	switch (ch) {
+		case void 0:
+		case " ":
+		case "\n":
+		case "\r":
+		case "	": return true;
+		default: return false;
+	}
+}
+const hexDigits = /* @__PURE__ */ new Set("0123456789ABCDEFabcdef");
+const tagChars = /* @__PURE__ */ new Set("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-#;/?:@&=+$_.!~*'()");
+const flowIndicatorChars = /* @__PURE__ */ new Set(",[]{}");
+const invalidAnchorChars = /* @__PURE__ */ new Set(" ,[]{}\n\r	");
+const isNotAnchorChar = (ch) => !ch || invalidAnchorChars.has(ch);
+/**
+* Splits an input string into lexical tokens, i.e. smaller strings that are
+* easily identifiable by `tokens.tokenType()`.
+*
+* Lexing starts always in a "stream" context. Incomplete input may be buffered
+* until a complete token can be emitted.
+*
+* In addition to slices of the original input, the following control characters
+* may also be emitted:
+*
+* - `\x02` (Start of Text): A document starts with the next token
+* - `\x18` (Cancel): Unexpected end of flow-mode (indicates an error)
+* - `\x1f` (Unit Separator): Next token is a scalar value
+* - `\u{FEFF}` (Byte order mark): Emitted separately outside documents
+*/
+var Lexer = class {
+	constructor() {
+		/**
+		* Flag indicating whether the end of the current buffer marks the end of
+		* all input
+		*/
+		this.atEnd = false;
+		/**
+		* Explicit indent set in block scalar header, as an offset from the current
+		* minimum indent, so e.g. set to 1 from a header `|2+`. Set to -1 if not
+		* explicitly set.
+		*/
+		this.blockScalarIndent = -1;
+		/**
+		* Block scalars that include a + (keep) chomping indicator in their header
+		* include trailing empty lines, which are otherwise excluded from the
+		* scalar's contents.
+		*/
+		this.blockScalarKeep = false;
+		/** Current input */
+		this.buffer = "";
+		/**
+		* Flag noting whether the map value indicator : can immediately follow this
+		* node within a flow context.
+		*/
+		this.flowKey = false;
+		/** Count of surrounding flow collection levels. */
+		this.flowLevel = 0;
+		/**
+		* Minimum level of indentation required for next lines to be parsed as a
+		* part of the current scalar value.
+		*/
+		this.indentNext = 0;
+		/** Indentation level of the current line. */
+		this.indentValue = 0;
+		/** Position of the next \n character. */
+		this.lineEndPos = null;
+		/** Stores the state of the lexer if reaching the end of incpomplete input */
+		this.next = null;
+		/** A pointer to `buffer`; the current position of the lexer. */
+		this.pos = 0;
+	}
+	/**
+	* Generate YAML tokens from the `source` string. If `incomplete`,
+	* a part of the last line may be left as a buffer for the next call.
+	*
+	* @returns A generator of lexical tokens
+	*/
+	*lex(source, incomplete = false) {
+		if (source) {
+			if (typeof source !== "string") throw TypeError("source is not a string");
+			this.buffer = this.buffer ? this.buffer + source : source;
+			this.lineEndPos = null;
+		}
+		this.atEnd = !incomplete;
+		let next = this.next ?? "stream";
+		while (next && (incomplete || this.hasChars(1))) next = yield* this.parseNext(next);
+	}
+	atLineEnd() {
+		let i = this.pos;
+		let ch = this.buffer[i];
+		while (ch === " " || ch === "	") ch = this.buffer[++i];
+		if (!ch || ch === "#" || ch === "\n") return true;
+		if (ch === "\r") return this.buffer[i + 1] === "\n";
+		return false;
+	}
+	charAt(n) {
+		return this.buffer[this.pos + n];
+	}
+	continueScalar(offset) {
+		let ch = this.buffer[offset];
+		if (this.indentNext > 0) {
+			let indent = 0;
+			while (ch === " ") ch = this.buffer[++indent + offset];
+			if (ch === "\r") {
+				const next = this.buffer[indent + offset + 1];
+				if (next === "\n" || !next && !this.atEnd) return offset + indent + 1;
+			}
+			return ch === "\n" || indent >= this.indentNext || !ch && !this.atEnd ? offset + indent : -1;
+		}
+		if (ch === "-" || ch === ".") {
+			const dt = this.buffer.substr(offset, 3);
+			if ((dt === "---" || dt === "...") && isEmpty(this.buffer[offset + 3])) return -1;
+		}
+		return offset;
+	}
+	getLine() {
+		let end = this.lineEndPos;
+		if (typeof end !== "number" || end !== -1 && end < this.pos) {
+			end = this.buffer.indexOf("\n", this.pos);
+			this.lineEndPos = end;
+		}
+		if (end === -1) return this.atEnd ? this.buffer.substring(this.pos) : null;
+		if (this.buffer[end - 1] === "\r") end -= 1;
+		return this.buffer.substring(this.pos, end);
+	}
+	hasChars(n) {
+		return this.pos + n <= this.buffer.length;
+	}
+	setNext(state) {
+		this.buffer = this.buffer.substring(this.pos);
+		this.pos = 0;
+		this.lineEndPos = null;
+		this.next = state;
+		return null;
+	}
+	peek(n) {
+		return this.buffer.substr(this.pos, n);
+	}
+	*parseNext(next) {
+		switch (next) {
+			case "stream": return yield* this.parseStream();
+			case "line-start": return yield* this.parseLineStart();
+			case "block-start": return yield* this.parseBlockStart();
+			case "doc": return yield* this.parseDocument();
+			case "flow": return yield* this.parseFlowCollection();
+			case "quoted-scalar": return yield* this.parseQuotedScalar();
+			case "block-scalar": return yield* this.parseBlockScalar();
+			case "plain-scalar": return yield* this.parsePlainScalar();
+		}
+	}
+	*parseStream() {
+		let line = this.getLine();
+		if (line === null) return this.setNext("stream");
+		if (line[0] === "") {
+			yield* this.pushCount(1);
+			line = line.substring(1);
+		}
+		if (line[0] === "%") {
+			let dirEnd = line.length;
+			let cs = line.indexOf("#");
+			while (cs !== -1) {
+				const ch = line[cs - 1];
+				if (ch === " " || ch === "	") {
+					dirEnd = cs - 1;
+					break;
+				} else cs = line.indexOf("#", cs + 1);
+			}
+			while (true) {
+				const ch = line[dirEnd - 1];
+				if (ch === " " || ch === "	") dirEnd -= 1;
+				else break;
+			}
+			const n = (yield* this.pushCount(dirEnd)) + (yield* this.pushSpaces(true));
+			yield* this.pushCount(line.length - n);
+			this.pushNewline();
+			return "stream";
+		}
+		if (this.atLineEnd()) {
+			const sp = yield* this.pushSpaces(true);
+			yield* this.pushCount(line.length - sp);
+			yield* this.pushNewline();
+			return "stream";
+		}
+		yield "";
+		return yield* this.parseLineStart();
+	}
+	*parseLineStart() {
+		const ch = this.charAt(0);
+		if (!ch && !this.atEnd) return this.setNext("line-start");
+		if (ch === "-" || ch === ".") {
+			if (!this.atEnd && !this.hasChars(4)) return this.setNext("line-start");
+			const s = this.peek(3);
+			if ((s === "---" || s === "...") && isEmpty(this.charAt(3))) {
+				yield* this.pushCount(3);
+				this.indentValue = 0;
+				this.indentNext = 0;
+				return s === "---" ? "doc" : "stream";
+			}
+		}
+		this.indentValue = yield* this.pushSpaces(false);
+		if (this.indentNext > this.indentValue && !isEmpty(this.charAt(1))) this.indentNext = this.indentValue;
+		return yield* this.parseBlockStart();
+	}
+	*parseBlockStart() {
+		const [ch0, ch1] = this.peek(2);
+		if (!ch1 && !this.atEnd) return this.setNext("block-start");
+		if ((ch0 === "-" || ch0 === "?" || ch0 === ":") && isEmpty(ch1)) {
+			const n = (yield* this.pushCount(1)) + (yield* this.pushSpaces(true));
+			this.indentNext = this.indentValue + 1;
+			this.indentValue += n;
+			return yield* this.parseBlockStart();
+		}
+		return "doc";
+	}
+	*parseDocument() {
+		yield* this.pushSpaces(true);
+		const line = this.getLine();
+		if (line === null) return this.setNext("doc");
+		let n = yield* this.pushIndicators();
+		switch (line[n]) {
+			case "#": yield* this.pushCount(line.length - n);
+			case void 0:
+				yield* this.pushNewline();
+				return yield* this.parseLineStart();
+			case "{":
+			case "[":
+				yield* this.pushCount(1);
+				this.flowKey = false;
+				this.flowLevel = 1;
+				return "flow";
+			case "}":
+			case "]":
+				yield* this.pushCount(1);
+				return "doc";
+			case "*":
+				yield* this.pushUntil(isNotAnchorChar);
+				return "doc";
+			case "\"":
+			case "'": return yield* this.parseQuotedScalar();
+			case "|":
+			case ">":
+				n += yield* this.parseBlockScalarHeader();
+				n += yield* this.pushSpaces(true);
+				yield* this.pushCount(line.length - n);
+				yield* this.pushNewline();
+				return yield* this.parseBlockScalar();
+			default: return yield* this.parsePlainScalar();
+		}
+	}
+	*parseFlowCollection() {
+		let nl, sp;
+		let indent = -1;
+		do {
+			nl = yield* this.pushNewline();
+			if (nl > 0) {
+				sp = yield* this.pushSpaces(false);
+				this.indentValue = indent = sp;
+			} else sp = 0;
+			sp += yield* this.pushSpaces(true);
+		} while (nl + sp > 0);
+		const line = this.getLine();
+		if (line === null) return this.setNext("flow");
+		if (indent !== -1 && indent < this.indentNext && line[0] !== "#" || indent === 0 && (line.startsWith("---") || line.startsWith("...")) && isEmpty(line[3])) {
+			if (!(indent === this.indentNext - 1 && this.flowLevel === 1 && (line[0] === "]" || line[0] === "}"))) {
+				this.flowLevel = 0;
+				yield "";
+				return yield* this.parseLineStart();
+			}
+		}
+		let n = 0;
+		while (line[n] === ",") {
+			n += yield* this.pushCount(1);
+			n += yield* this.pushSpaces(true);
+			this.flowKey = false;
+		}
+		n += yield* this.pushIndicators();
+		switch (line[n]) {
+			case void 0: return "flow";
+			case "#":
+				yield* this.pushCount(line.length - n);
+				return "flow";
+			case "{":
+			case "[":
+				yield* this.pushCount(1);
+				this.flowKey = false;
+				this.flowLevel += 1;
+				return "flow";
+			case "}":
+			case "]":
+				yield* this.pushCount(1);
+				this.flowKey = true;
+				this.flowLevel -= 1;
+				return this.flowLevel ? "flow" : "doc";
+			case "*":
+				yield* this.pushUntil(isNotAnchorChar);
+				return "flow";
+			case "\"":
+			case "'":
+				this.flowKey = true;
+				return yield* this.parseQuotedScalar();
+			case ":": {
+				const next = this.charAt(1);
+				if (this.flowKey || isEmpty(next) || next === ",") {
+					this.flowKey = false;
+					yield* this.pushCount(1);
+					yield* this.pushSpaces(true);
+					return "flow";
+				}
+			}
+			default:
+				this.flowKey = false;
+				return yield* this.parsePlainScalar();
+		}
+	}
+	*parseQuotedScalar() {
+		const quote = this.charAt(0);
+		let end = this.buffer.indexOf(quote, this.pos + 1);
+		if (quote === "'") while (end !== -1 && this.buffer[end + 1] === "'") end = this.buffer.indexOf("'", end + 2);
+		else while (end !== -1) {
+			let n = 0;
+			while (this.buffer[end - 1 - n] === "\\") n += 1;
+			if (n % 2 === 0) break;
+			end = this.buffer.indexOf("\"", end + 1);
+		}
+		const qb = this.buffer.substring(0, end);
+		let nl = qb.indexOf("\n", this.pos);
+		if (nl !== -1) {
+			while (nl !== -1) {
+				const cs = this.continueScalar(nl + 1);
+				if (cs === -1) break;
+				nl = qb.indexOf("\n", cs);
+			}
+			if (nl !== -1) end = nl - (qb[nl - 1] === "\r" ? 2 : 1);
+		}
+		if (end === -1) {
+			if (!this.atEnd) return this.setNext("quoted-scalar");
+			end = this.buffer.length;
+		}
+		yield* this.pushToIndex(end + 1, false);
+		return this.flowLevel ? "flow" : "doc";
+	}
+	*parseBlockScalarHeader() {
+		this.blockScalarIndent = -1;
+		this.blockScalarKeep = false;
+		let i = this.pos;
+		while (true) {
+			const ch = this.buffer[++i];
+			if (ch === "+") this.blockScalarKeep = true;
+			else if (ch > "0" && ch <= "9") this.blockScalarIndent = Number(ch) - 1;
+			else if (ch !== "-") break;
+		}
+		return yield* this.pushUntil((ch) => isEmpty(ch) || ch === "#");
+	}
+	*parseBlockScalar() {
+		let nl = this.pos - 1;
+		let indent = 0;
+		let ch;
+		loop: for (let i = this.pos; ch = this.buffer[i]; ++i) switch (ch) {
+			case " ":
+				indent += 1;
+				break;
+			case "\n":
+				nl = i;
+				indent = 0;
+				break;
+			case "\r": {
+				const next = this.buffer[i + 1];
+				if (!next && !this.atEnd) return this.setNext("block-scalar");
+				if (next === "\n") break;
+			}
+			default: break loop;
+		}
+		if (!ch && !this.atEnd) return this.setNext("block-scalar");
+		if (indent >= this.indentNext) {
+			if (this.blockScalarIndent === -1) this.indentNext = indent;
+			else this.indentNext = this.blockScalarIndent + (this.indentNext === 0 ? 1 : this.indentNext);
+			do {
+				const cs = this.continueScalar(nl + 1);
+				if (cs === -1) break;
+				nl = this.buffer.indexOf("\n", cs);
+			} while (nl !== -1);
+			if (nl === -1) {
+				if (!this.atEnd) return this.setNext("block-scalar");
+				nl = this.buffer.length;
+			}
+		}
+		let i = nl + 1;
+		ch = this.buffer[i];
+		while (ch === " ") ch = this.buffer[++i];
+		if (ch === "	") {
+			while (ch === "	" || ch === " " || ch === "\r" || ch === "\n") ch = this.buffer[++i];
+			nl = i - 1;
+		} else if (!this.blockScalarKeep) do {
+			let i = nl - 1;
+			let ch = this.buffer[i];
+			if (ch === "\r") ch = this.buffer[--i];
+			const lastChar = i;
+			while (ch === " ") ch = this.buffer[--i];
+			if (ch === "\n" && i >= this.pos && i + 1 + indent > lastChar) nl = i;
+			else break;
+		} while (true);
+		yield "";
+		yield* this.pushToIndex(nl + 1, true);
+		return yield* this.parseLineStart();
+	}
+	*parsePlainScalar() {
+		const inFlow = this.flowLevel > 0;
+		let end = this.pos - 1;
+		let i = this.pos - 1;
+		let ch;
+		while (ch = this.buffer[++i]) if (ch === ":") {
+			const next = this.buffer[i + 1];
+			if (isEmpty(next) || inFlow && flowIndicatorChars.has(next)) break;
+			end = i;
+		} else if (isEmpty(ch)) {
+			let next = this.buffer[i + 1];
+			if (ch === "\r") if (next === "\n") {
+				i += 1;
+				ch = "\n";
+				next = this.buffer[i + 1];
+			} else end = i;
+			if (next === "#" || inFlow && flowIndicatorChars.has(next)) break;
+			if (ch === "\n") {
+				const cs = this.continueScalar(i + 1);
+				if (cs === -1) break;
+				i = Math.max(i, cs - 2);
+			}
+		} else {
+			if (inFlow && flowIndicatorChars.has(ch)) break;
+			end = i;
+		}
+		if (!ch && !this.atEnd) return this.setNext("plain-scalar");
+		yield "";
+		yield* this.pushToIndex(end + 1, true);
+		return inFlow ? "flow" : "doc";
+	}
+	*pushCount(n) {
+		if (n > 0) {
+			yield this.buffer.substr(this.pos, n);
+			this.pos += n;
+			return n;
+		}
+		return 0;
+	}
+	*pushToIndex(i, allowEmpty) {
+		const s = this.buffer.slice(this.pos, i);
+		if (s) {
+			yield s;
+			this.pos += s.length;
+			return s.length;
+		} else if (allowEmpty) yield "";
+		return 0;
+	}
+	*pushIndicators() {
+		switch (this.charAt(0)) {
+			case "!": return (yield* this.pushTag()) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
+			case "&": return (yield* this.pushUntil(isNotAnchorChar)) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
+			case "-":
+			case "?":
+			case ":": {
+				const inFlow = this.flowLevel > 0;
+				const ch1 = this.charAt(1);
+				if (isEmpty(ch1) || inFlow && flowIndicatorChars.has(ch1)) {
+					if (!inFlow) this.indentNext = this.indentValue + 1;
+					else if (this.flowKey) this.flowKey = false;
+					return (yield* this.pushCount(1)) + (yield* this.pushSpaces(true)) + (yield* this.pushIndicators());
+				}
+			}
+		}
+		return 0;
+	}
+	*pushTag() {
+		if (this.charAt(1) === "<") {
+			let i = this.pos + 2;
+			let ch = this.buffer[i];
+			while (!isEmpty(ch) && ch !== ">") ch = this.buffer[++i];
+			return yield* this.pushToIndex(ch === ">" ? i + 1 : i, false);
+		} else {
+			let i = this.pos + 1;
+			let ch = this.buffer[i];
+			while (ch) if (tagChars.has(ch)) ch = this.buffer[++i];
+			else if (ch === "%" && hexDigits.has(this.buffer[i + 1]) && hexDigits.has(this.buffer[i + 2])) ch = this.buffer[i += 3];
+			else break;
+			return yield* this.pushToIndex(i, false);
+		}
+	}
+	*pushNewline() {
+		const ch = this.buffer[this.pos];
+		if (ch === "\n") return yield* this.pushCount(1);
+		else if (ch === "\r" && this.charAt(1) === "\n") return yield* this.pushCount(2);
+		else return 0;
+	}
+	*pushSpaces(allowTabs) {
+		let i = this.pos - 1;
+		let ch;
+		do
+			ch = this.buffer[++i];
+		while (ch === " " || allowTabs && ch === "	");
+		const n = i - this.pos;
+		if (n > 0) {
+			yield this.buffer.substr(this.pos, n);
+			this.pos = i;
+		}
+		return n;
+	}
+	*pushUntil(test) {
+		let i = this.pos;
+		let ch = this.buffer[i];
+		while (!test(ch)) ch = this.buffer[++i];
+		return yield* this.pushToIndex(i, false);
+	}
+};
+//#endregion
+export { Lexer };

package/dist/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/parse/line-counter.js

@@ -0,0 +1,45 @@
+//#region ../../node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/browser/dist/parse/line-counter.js
+/**
+* Tracks newlines during parsing in order to provide an efficient API for
+* determining the one-indexed `{ line, col }` position for any offset
+* within the input.
+*/
+var LineCounter = class {
+	constructor() {
+		this.lineStarts = [];
+		/**
+		* Should be called in ascending order. Otherwise, call
+		* `lineCounter.lineStarts.sort()` before calling `linePos()`.
+		*/
+		this.addNewLine = (offset) => this.lineStarts.push(offset);
+		/**
+		* Performs a binary search and returns the 1-indexed { line, col }
+		* position of `offset`. If `line === 0`, `addNewLine` has never been
+		* called or `offset` is before the first known newline.
+		*/
+		this.linePos = (offset) => {
+			let low = 0;
+			let high = this.lineStarts.length;
+			while (low < high) {
+				const mid = low + high >> 1;
+				if (this.lineStarts[mid] < offset) low = mid + 1;
+				else high = mid;
+			}
+			if (this.lineStarts[low] === offset) return {
+				line: low + 1,
+				col: 1
+			};
+			if (low === 0) return {
+				line: 0,
+				col: offset
+			};
+			const start = this.lineStarts[low - 1];
+			return {
+				line: low,
+				col: offset - start + 1
+			};
+		};
+	}
+};
+//#endregion
+export { LineCounter };