cngpac 0.0.1

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/parse/cst.mjs

@@ -0,0 +1,85 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_cst_scalar } from "./cst-scalar.mjs";
+import { require_cst_stringify } from "./cst-stringify.mjs";
+import { require_cst_visit } from "./cst-visit.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/parse/cst.js
+var require_cst = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var cstScalar = require_cst_scalar();
+	var cstStringify = require_cst_stringify();
+	var cstVisit = require_cst_visit();
+	/** The byte order mark */
+	const BOM = "";
+	/** Start of doc-mode */
+	const DOCUMENT = "";
+	/** Unexpected end of flow-mode */
+	const FLOW_END = "";
+	/** Next token is a scalar value */
+	const SCALAR = "";
+	/** @returns `true` if `token` is a flow or block collection */
+	const isCollection = (token) => !!token && "items" in token;
+	/** @returns `true` if `token` is a flow or block scalar; not an alias */
+	const isScalar = (token) => !!token && (token.type === "scalar" || token.type === "single-quoted-scalar" || token.type === "double-quoted-scalar" || token.type === "block-scalar");
+	/* istanbul ignore next */
+	/** Get a printable representation of a lexer token */
+	function prettyToken(token) {
+		switch (token) {
+			case BOM: return "<BOM>";
+			case DOCUMENT: return "<DOC>";
+			case FLOW_END: return "<FLOW_END>";
+			case SCALAR: return "<SCALAR>";
+			default: return JSON.stringify(token);
+		}
+	}
+	/** Identify the type of a lexer token. May return `null` for unknown tokens. */
+	function tokenType(source) {
+		switch (source) {
+			case BOM: return "byte-order-mark";
+			case DOCUMENT: return "doc-mode";
+			case FLOW_END: return "flow-error-end";
+			case SCALAR: 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;
+	}
+	exports.createScalarToken = cstScalar.createScalarToken;
+	exports.resolveAsScalar = cstScalar.resolveAsScalar;
+	exports.setScalarValue = cstScalar.setScalarValue;
+	exports.stringify = cstStringify.stringify;
+	exports.visit = cstVisit.visit;
+	exports.BOM = BOM;
+	exports.DOCUMENT = DOCUMENT;
+	exports.FLOW_END = FLOW_END;
+	exports.SCALAR = SCALAR;
+	exports.isCollection = isCollection;
+	exports.isScalar = isScalar;
+	exports.prettyToken = prettyToken;
+	exports.tokenType = tokenType;
+}));
+//#endregion
+export default require_cst();
+export { require_cst };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/parse/lexer.mjs

@@ -0,0 +1,523 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+import { require_cst } from "./cst.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/parse/lexer.js
+var require_lexer = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var cst = require_cst();
+	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] === cst.BOM) {
+				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 cst.DOCUMENT;
+			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 cst.FLOW_END;
+					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 cst.SCALAR;
+			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 cst.SCALAR;
+			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);
+		}
+	};
+	exports.Lexer = Lexer;
+}));
+//#endregion
+export default require_lexer();
+export { require_lexer };

package/dist/src/node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/parse/line-counter.mjs

@@ -0,0 +1,50 @@
+import { __commonJSMin } from "../../../../../../../_virtual/_rolldown/runtime.mjs";
+//#region node_modules/.pnpm/yaml@2.8.3/node_modules/yaml/dist/parse/line-counter.js
+var require_line_counter = /* @__PURE__ */ __commonJSMin(((exports) => {
+	/**
+	* 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
+				};
+			};
+		}
+	};
+	exports.LineCounter = LineCounter;
+}));
+//#endregion
+export default require_line_counter();
+export { require_line_counter };