@effected/yaml 0.25.0 → 0.26.0

package/internal/composer/comments.js

@@ -169,44 +169,22 @@ function columnAt(text, offset) {
 * included.
 */
 function withCommentFields(node, fields) {
+	const merged = mergedCommentFields(node, fields);
 	if (node instanceof YamlScalar) return new YamlScalar({
-		value: node.value,
-		style: node.style,
-		...node.tag !== void 0 ? { tag: node.tag } : {},
-		...node.anchor !== void 0 ? { anchor: node.anchor } : {},
-		...mergedCommentFields(node, fields),
-		...node.chomp !== void 0 ? { chomp: node.chomp } : {},
-		...node.blockIndent !== void 0 ? { blockIndent: node.blockIndent } : {},
-		...node.raw !== void 0 ? { raw: node.raw } : {},
-		...node.sourceMultiline !== void 0 ? { sourceMultiline: node.sourceMultiline } : {},
-		offset: node.offset,
-		length: node.length
+		...node,
+		...merged
 	});
 	if (node instanceof YamlMap) return new YamlMap({
-		items: node.items,
-		style: node.style,
-		...node.tag !== void 0 ? { tag: node.tag } : {},
-		...node.anchor !== void 0 ? { anchor: node.anchor } : {},
-		...mergedCommentFields(node, fields),
-		...node.sourceMultiline !== void 0 ? { sourceMultiline: node.sourceMultiline } : {},
-		offset: node.offset,
-		length: node.length
+		...node,
+		...merged
 	});
 	if (node instanceof YamlSeq) return new YamlSeq({
-		items: node.items,
-		style: node.style,
-		...node.tag !== void 0 ? { tag: node.tag } : {},
-		...node.anchor !== void 0 ? { anchor: node.anchor } : {},
-		...mergedCommentFields(node, fields),
-		...node.sourceMultiline !== void 0 ? { sourceMultiline: node.sourceMultiline } : {},
-		offset: node.offset,
-		length: node.length
+		...node,
+		...merged
 	});
 	return new YamlAlias({
-		name: node.name,
-		...mergedCommentFields(node, fields),
-		offset: node.offset,
-		length: node.length
+		...node,
+		...merged
 	});
 }
 function mergedCommentFields(existing, incoming) {

package/internal/composer/scalars.js

@@ -285,7 +285,7 @@ function decodeDoubleQuoted(raw) {
 * - Leading whitespace (indentation) on continuation lines trimmed
 */
 function foldFlowLines(text) {
-	const lines = text.split("\n");
+	const lines = text.split(/\r?\n/);
 	let result = "";
 	for (let i = 0; i < lines.length; i++) {
 		const line = lines[i] ?? "";
@@ -660,18 +660,33 @@ function findParentIndent(fullText, indicatorOffset) {
 	let scanBack = indicatorOffset - 1;
 	while (scanBack >= 0 && (fullText[scanBack] === " " || fullText[scanBack] === "	")) scanBack--;
 	if (scanBack >= 0 && fullText[scanBack] === ":") return findKeyIndent(fullText, scanBack);
-	if (scanBack >= 0 && fullText[scanBack] === "-") return findColOnLine(fullText, scanBack);
+	if (scanBack >= 0 && fullText[scanBack] === "-") return isDocumentStartDash(fullText, scanBack) ? 0 : findColOnLine(fullText, scanBack);
 	while (scanBack >= 0) {
 		const ch = fullText[scanBack];
 		if (ch === ":") return findKeyIndent(fullText, scanBack);
 		if (ch === "-") {
 			const afterDash = scanBack + 1;
-			if (afterDash >= fullText.length || fullText[afterDash] === " " || fullText[afterDash] === "	" || fullText[afterDash] === "\n" || fullText[afterDash] === "\r") return findColOnLine(fullText, scanBack);
+			if (afterDash >= fullText.length || fullText[afterDash] === " " || fullText[afterDash] === "	" || fullText[afterDash] === "\n" || fullText[afterDash] === "\r") return isDocumentStartDash(fullText, scanBack) ? 0 : findColOnLine(fullText, scanBack);
 		}
 		scanBack--;
 	}
 	return 0;
 }
+/**
+* True when the `-` at `pos` belongs to a `---` document-start marker. The
+* marker opens a document at the top level, so a block scalar after it has
+* the root's parent indent, 0. Taking its last `-` for a sequence entry put
+* the parent at column 2: `---\n>1\n #:a` decoded to `""` where `>1\n #:a`
+* decodes to `"#:a\n"`, and inserting the marker (`document-start`'s fix)
+* changed the value.
+*/
+function isDocumentStartDash(text, pos) {
+	let lineStart = pos;
+	while (lineStart > 0 && text[lineStart - 1] !== "\n" && text[lineStart - 1] !== "\r") lineStart--;
+	if (pos - lineStart > 2 || !text.startsWith("---", lineStart)) return false;
+	const after = text[lineStart + 3];
+	return after === void 0 || after === " " || after === "	" || after === "\n" || after === "\r";
+}
 /** Find the column of a character on its line. */
 function findColOnLine(text, pos) {
 	let lineStart = pos;

package/internal/composer/state.js

@@ -1,3 +1,5 @@
+import { normalizeLineBreaks } from "../line-breaks.js";
+
 // src/internal/composer/state.ts
 let lineStartsText;
 let lineStartsCache = [];
@@ -85,7 +87,7 @@ function commentProps(n) {
 }
 function createState(text, flow, options) {
 	return {
-		text,
+		text: normalizeLineBreaks(text),
 		anchors: /* @__PURE__ */ new Map(),
 		aliasCount: 0,
 		errors: [],

package/internal/cst-parser.js

@@ -1,3 +1,4 @@
+import { normalizeLineBreaks } from "./line-breaks.js";
 import { lexAll } from "./lexer.js";
 
 // src/internal/cst-parser.ts
@@ -717,7 +718,8 @@ function parseDocuments(tokens, text) {
 * whitespace, comments, and structural indicators. No value interpretation
 * occurs at this stage — `true` is still the string `"true"`.
 */
-function parseCSTAll(text) {
+function parseCSTAll(source) {
+	const text = normalizeLineBreaks(source);
 	return parseDocuments(lexAll(text), text);
 }
 

package/internal/lexer.js

@@ -1,3 +1,5 @@
+import { normalizeLineBreaks } from "./line-breaks.js";
+
 // src/internal/lexer.ts
 /**
 * Create a new YAML scanner for the given source text.
@@ -5,7 +7,8 @@
 * Returns a stateful, pull-based scanner. Call {@link YamlScanner.scan} to
 * advance to the next token, then use `getToken*` methods to inspect it.
 */
-function createScanner(text) {
+function createScanner(source) {
+	const text = normalizeLineBreaks(source);
 	let pos = 0;
 	let line = 0;
 	let col = 0;

package/internal/line-breaks.js

@@ -0,0 +1,12 @@
+// src/internal/line-breaks.ts
+const BARE_CR = /\r(?!\n)/g;
+/**
+* `text` with every bare `\r` (one not followed by `\n`) replaced by `\n`.
+* Returns `text` itself when it holds no `\r`, so the common case allocates
+* nothing and reference-keyed caches downstream keep hitting.
+*
+* @internal
+*/
+const normalizeLineBreaks = (text) => text.indexOf("\r") === -1 ? text : text.replace(BARE_CR, "\n");
+
+export { normalizeLineBreaks };

package/internal/rules/colon-spacing.js

@@ -1,6 +1,6 @@
 import { YamlEdit } from "../../YamlEdit.js";
 import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
-import { nonNegativeIntegerOption, positiveIntegerOption } from "./util.js";
+import { composedScalars, insideComposedScalar, laterLineInWindow, nonNegativeIntegerOption, positiveIntegerOption } from "./util.js";
 import { Schema } from "effect";
 
 // src/internal/rules/colon-spacing.ts
@@ -26,26 +26,14 @@ const colonSpacing = {
 		const out = [];
 		for (const token of ctx.tokens) {
 			if (token.kind !== "block-map-value") continue;
+			if (insideComposedScalar(ctx, token.offset)) continue;
 			let i = token.offset - 1;
 			let before = 0;
 			while (i >= 0 && ctx.text[i] === " ") {
 				before++;
 				i--;
 			}
-			if (i >= 0 && ctx.text[i] !== "\n" && ctx.text[i] !== "\r" && ctx.text[i] !== "	" && before > maxBefore) out.push(new YamlLintDiagnostic({
-				rule: "colon-spacing",
-				severity: "error",
-				message: `Too many spaces before ":" (${before} > ${maxBefore})`,
-				offset: token.offset - before,
-				length: before,
-				line: token.line,
-				character: token.character - before,
-				fix: YamlEdit.make({
-					offset: token.offset - before,
-					length: before - maxBefore,
-					content: ""
-				})
-			}));
+			const hasContentBefore = i >= 0 && ctx.text[i] !== "\n" && ctx.text[i] !== "\r" && ctx.text[i] !== "	";
 			let j = token.offset + token.length;
 			let after = 0;
 			while (j < ctx.text.length && ctx.text[j] === " ") {
@@ -53,8 +41,30 @@ const colonSpacing = {
 				j++;
 			}
 			const next = ctx.text[j];
-			if (next === void 0 || next === "\n" || next === "\r" || next === "#") continue;
-			if (after > maxAfter) out.push(new YamlLintDiagnostic({
+			const inlineValue = next !== void 0 && next !== "\n" && next !== "\r" && next !== "#";
+			const shiftBefore = hasContentBefore && before > maxBefore ? before - maxBefore : 0;
+			const shiftAfter = inlineValue && after > maxAfter ? after - maxAfter : 0;
+			const valueColumn = token.character + token.length + after;
+			const moveSafe = !inlineValue || !laterLineInWindow(ctx, token.line, token.character - shiftBefore, valueColumn - shiftBefore - shiftAfter, valueColumn);
+			if (shiftBefore > 0) {
+				const keyEnd = i + 1;
+				const safe = moveSafe && (maxBefore === 0 ? composedScalars(ctx).some((scalar) => scalar.end === keyEnd && scalar.role === "key") : true);
+				out.push(new YamlLintDiagnostic({
+					rule: "colon-spacing",
+					severity: "error",
+					message: `Too many spaces before ":" (${before} > ${maxBefore})`,
+					offset: token.offset - before,
+					length: before,
+					line: token.line,
+					character: token.character - before,
+					...safe ? { fix: YamlEdit.make({
+						offset: token.offset - before,
+						length: before - maxBefore,
+						content: ""
+					}) } : {}
+				}));
+			}
+			if (shiftAfter > 0) out.push(new YamlLintDiagnostic({
 				rule: "colon-spacing",
 				severity: "error",
 				message: `Too many spaces after ":" (${after} > ${maxAfter})`,
@@ -62,11 +72,11 @@ const colonSpacing = {
 				length: after,
 				line: token.line,
 				character: token.character + token.length,
-				fix: YamlEdit.make({
+				...moveSafe ? { fix: YamlEdit.make({
 					offset: token.offset + token.length,
-					length: after - maxAfter,
+					length: shiftAfter,
 					content: ""
-				})
+				}) } : {}
 			}));
 		}
 		return out;

package/internal/rules/comments-spacing.js

@@ -1,6 +1,6 @@
 import { YamlEdit } from "../../YamlEdit.js";
 import { StyleVote, YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
-import { nonNegativeIntegerOption } from "./util.js";
+import { insideComposedScalar, nonNegativeIntegerOption } from "./util.js";
 import { Schema } from "effect";
 
 // src/internal/rules/comments-spacing.ts
@@ -31,6 +31,13 @@ const spacingBefore = (ctx, token) => {
 		hasContentBefore: i >= 0 && ctx.text[i] !== "\n" && ctx.text[i] !== "\r"
 	};
 };
+/**
+* A `comment` token the composer reads as scalar CONTENT is no comment: on
+* `1-\n - ##` the composer folds the second line into the plain scalar
+* `"1- - ##"`, so inserting a space after the `#` edited the value. Such a
+* token neither reports nor votes.
+*/
+const isContent = (ctx, token) => insideComposedScalar(ctx, token.offset);
 /** Shebang exemption: `#!` at the very start of the stream. */
 const isShebang = (token) => token.offset === 0 && token.text.startsWith("#!");
 /** Comment spacing: after the `#`, and before a trailing comment's `#`. */
@@ -43,7 +50,7 @@ const commentsSpacing = {
 		const out = [];
 		for (const token of ctx.tokens) {
 			if (token.kind !== "comment") continue;
-			if (isShebang(token)) continue;
+			if (isShebang(token) || isContent(ctx, token)) continue;
 			if (requireAfter && token.text.length > 1 && !/[ \t]/.test(token.text[1])) out.push(new YamlLintDiagnostic({
 				rule: "comments-spacing",
 				severity: "error",
@@ -80,7 +87,7 @@ const commentsSpacing = {
 		const out = [];
 		for (const token of ctx.tokens) {
 			if (token.kind !== "comment") continue;
-			if (isShebang(token)) continue;
+			if (isShebang(token) || isContent(ctx, token)) continue;
 			if (token.text.length > 1) out.push(StyleVote.make({
 				dimension: "requireSpaceAfter",
 				value: /[ \t]/.test(token.text[1]),

package/internal/rules/document-end.js

@@ -1,5 +1,6 @@
 import { YamlEdit } from "../../YamlEdit.js";
 import { StyleVote, YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { endsWithLineBreak } from "./util.js";
 import { Schema } from "effect";
 
 // src/internal/rules/document-end.ts
@@ -25,7 +26,7 @@ const tailToken = (ctx) => [...ctx.tokens].reverse().find((t) => !TRIVIA.has(t.k
 */
 const endOfStreamPosition = (ctx) => {
 	const lastLine = ctx.lines[ctx.lines.length - 1];
-	const trailingNewline = ctx.text.endsWith("\n");
+	const trailingNewline = endsWithLineBreak(ctx.text);
 	return {
 		offset: ctx.text.length,
 		length: 0,
@@ -48,7 +49,7 @@ const documentEnd = {
 			fix: YamlEdit.make({
 				offset: ctx.text.length,
 				length: 0,
-				content: ctx.text.endsWith("\n") ? "...\n" : "\n...\n"
+				content: endsWithLineBreak(ctx.text) ? "...\n" : "\n...\n"
 			})
 		})];
 		if (!present && tail !== void 0 && tail.kind === "document-end") {

package/internal/rules/empty-lines.js

@@ -1,6 +1,6 @@
 import { YamlEdit } from "../../YamlEdit.js";
 import { StyleFloor, YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
-import { insideScalarSpan, nonNegativeIntegerOption } from "./util.js";
+import { insideComposedScalar, insideScalarSpan, nonNegativeIntegerOption } from "./util.js";
 import { Schema } from "effect";
 
 // src/internal/rules/empty-lines.ts
@@ -15,6 +15,15 @@ const emptyLinesOptions = Schema.Struct({
 	maxStart: Schema.optionalKey(nonNegativeIntegerOption),
 	maxEnd: Schema.optionalKey(nonNegativeIntegerOption)
 });
+/**
+* Whether a blank line at `offset` is scalar CONTENT: inside a block scalar
+* token, or inside any scalar the composer reads. The second half matters
+* for a multi-line plain or quoted scalar, which the lexer splits into one
+* token per line: its blank lines sit between tokens, yet each one folds
+* into the value as a line break (`a\n\n\n\nb` is `"a\n\n\nb"`), so deleting
+* one changes the value.
+*/
+const insideScalarContent = (ctx, offset) => insideScalarSpan(ctx.tokens, offset) || insideComposedScalar(ctx, offset);
 /** Runs of blank lines beyond the configured caps, with a deleting fix. */
 const emptyLines = {
 	id: "empty-lines",
@@ -28,7 +37,7 @@ const emptyLines = {
 		let i = 0;
 		while (i < lines.length) {
 			const line = lines[i];
-			if (line === void 0 || line.text !== "" || insideScalarSpan(ctx.tokens, line.offset)) {
+			if (line === void 0 || line.text !== "" || insideScalarContent(ctx, line.offset)) {
 				i++;
 				continue;
 			}
@@ -70,7 +79,7 @@ const emptyLines = {
 		let i = 0;
 		while (i < lines.length) {
 			const line = lines[i];
-			if (line === void 0 || line.text !== "" || insideScalarSpan(ctx.tokens, line.offset)) {
+			if (line === void 0 || line.text !== "" || insideScalarContent(ctx, line.offset)) {
 				i++;
 				continue;
 			}

package/internal/rules/eof-newline.js

@@ -1,5 +1,6 @@
 import { YamlEdit } from "../../YamlEdit.js";
 import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { endsWithLineBreak } from "./util.js";
 import { Schema } from "effect";
 
 // src/internal/rules/eof-newline.ts
@@ -9,7 +10,7 @@ const eofNewlineOptions = Schema.Struct({ severity: Schema.optionalKey(YamlLintS
 const eofNewline = {
 	id: "eof-newline",
 	check: (ctx) => {
-		if (ctx.text.length === 0 || ctx.text.endsWith("\n")) return [];
+		if (ctx.text.length === 0 || endsWithLineBreak(ctx.text)) return [];
 		const lastLine = ctx.lines[ctx.lines.length - 1];
 		if (lastLine === void 0) return [];
 		return [new YamlLintDiagnostic({

package/internal/rules/hyphen-spacing.js

@@ -1,6 +1,6 @@
 import { YamlEdit } from "../../YamlEdit.js";
 import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
-import { positiveIntegerOption } from "./util.js";
+import { insideComposedScalar, laterLineInWindow, positiveIntegerOption } from "./util.js";
 import { Schema } from "effect";
 
 // src/internal/rules/hyphen-spacing.ts
@@ -21,6 +21,7 @@ const hyphenSpacing = {
 		const out = [];
 		for (const token of ctx.tokens) {
 			if (token.kind !== "block-seq-entry") continue;
+			if (insideComposedScalar(ctx, token.offset)) continue;
 			let j = token.offset + token.length;
 			let after = 0;
 			while (j < ctx.text.length && ctx.text[j] === " ") {
@@ -29,20 +30,25 @@ const hyphenSpacing = {
 			}
 			const next = ctx.text[j];
 			if (next === void 0 || next === "\n" || next === "\r" || next === "#") continue;
-			if (after > maxAfter) out.push(new YamlLintDiagnostic({
-				rule: "hyphen-spacing",
-				severity: "error",
-				message: `Too many spaces after "-" (${after} > ${maxAfter})`,
-				offset: token.offset + token.length,
-				length: after,
-				line: token.line,
-				character: token.character + token.length,
-				fix: YamlEdit.make({
+			if (after > maxAfter) {
+				const oldColumn = token.character + token.length + after;
+				const newColumn = token.character + token.length + maxAfter;
+				const safe = !laterLineInWindow(ctx, token.line, token.character, newColumn, oldColumn);
+				out.push(new YamlLintDiagnostic({
+					rule: "hyphen-spacing",
+					severity: "error",
+					message: `Too many spaces after "-" (${after} > ${maxAfter})`,
 					offset: token.offset + token.length,
-					length: after - maxAfter,
-					content: ""
-				})
-			}));
+					length: after,
+					line: token.line,
+					character: token.character + token.length,
+					...safe ? { fix: YamlEdit.make({
+						offset: token.offset + token.length,
+						length: after - maxAfter,
+						content: ""
+					}) } : {}
+				}));
+			}
 		}
 		return out;
 	}

package/internal/rules/trailing-spaces.js

@@ -1,6 +1,6 @@
 import { YamlEdit } from "../../YamlEdit.js";
 import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
-import { insideScalarSpan } from "./util.js";
+import { insideComposedScalar, insideScalarSpan } from "./util.js";
 import { Schema } from "effect";
 
 // src/internal/rules/trailing-spaces.ts
@@ -15,7 +15,7 @@ const trailingSpaces = {
 			const match = /[ \t]+$/.exec(line.text);
 			if (match === null) continue;
 			const runOffset = line.offset + match.index;
-			if (insideScalarSpan(ctx.tokens, runOffset)) continue;
+			if (insideScalarSpan(ctx.tokens, runOffset) || insideComposedScalar(ctx, runOffset)) continue;
 			out.push(new YamlLintDiagnostic({
 				rule: "trailing-spaces",
 				severity: "error",

package/internal/rules/util.js

@@ -1,8 +1,16 @@
 import { YamlMap, YamlScalar, YamlSeq } from "../../YamlNode.js";
+import { composeAllDocuments } from "../composer/document.js";
 import { Schema } from "effect";
 
 // src/internal/rules/util.ts
 /**
+* Whether `text` ends in a line break. A bare `\r` counts, as it does
+* everywhere positions are computed (YAML 1.2 `b-break`, the lexer's
+* `newline` token, `LintLine` splitting): a bare-CR document lints the way
+* its LF twin does.
+*/
+const endsWithLineBreak = (text) => text.endsWith("\n") || text.endsWith("\r");
+/**
 * A non-negative integer — the shape every numeric rule option takes.
 * Rejects NaN, negatives and fractions with a message naming the constraint;
 * the config layer's wrapper names the rule and the field.
@@ -87,5 +95,88 @@ function positionAt(lines, offset) {
 		character: offset - found.offset
 	};
 }
+const composedScalarsCache = /* @__PURE__ */ new WeakMap();
+const composedContentsCache = /* @__PURE__ */ new WeakMap();
+/**
+* The composed contents of every document in the context's text. The lint
+* context carries only the FIRST document, and a fix in a later one must be
+* judged against what the composer reads there too.
+*/
+function composedContents(ctx) {
+	const cached = composedContentsCache.get(ctx);
+	if (cached !== void 0) return cached;
+	const contents = composeAllDocuments(ctx.text, { uniqueKeys: false }).documents.map((d) => d.contents);
+	composedContentsCache.set(ctx, contents);
+	return contents;
+}
+/**
+* Every scalar the COMPOSER reads in the context's text, across all of its
+* documents, ordered by offset. Built once per lint context, on first use.
+*
+* Tokens are the lexer's view and can disagree with the composer: on
+* `"b\n -  a"` the lexer emits a `block-seq-entry` for the `-` while the
+* composer folds the second line into the plain scalar `"b -  a"`. A fix
+* keyed on that token edits scalar content and changes the parsed value, so
+* a fix that must stay off content asks the composer instead.
+*/
+function composedScalars(ctx) {
+	const cached = composedScalarsCache.get(ctx);
+	if (cached !== void 0) return cached;
+	const out = [];
+	for (const contents of composedContents(ctx)) walkScalars(contents, "root", (scalar, role) => {
+		out.push({
+			offset: scalar.offset,
+			end: scalar.offset + scalar.length,
+			role,
+			style: scalar.style
+		});
+	});
+	out.sort((a, b) => a.offset - b.offset);
+	composedScalarsCache.set(ctx, out);
+	return out;
+}
+/**
+* True when `offset` is CONTENT of a scalar the composer reads: inside its
+* span `[offset, end)` and past its first character. Scalars never nest, so
+* the spans are disjoint and a binary search finds the only candidate.
+*/
+function insideComposedScalar(ctx, offset) {
+	const scalars = composedScalars(ctx);
+	let lo = 0;
+	let hi = scalars.length - 1;
+	let found;
+	while (lo <= hi) {
+		const mid = lo + hi >> 1;
+		const scalar = scalars[mid];
+		if (scalar.offset <= offset) {
+			found = scalar;
+			lo = mid + 1;
+		} else hi = mid - 1;
+	}
+	return found !== void 0 && offset > found.offset && offset < found.end;
+}
+/**
+* True when a later line of the same construct starts in the column window
+* `[lo, hi]` — the columns a spacing fix moves content across when it
+* shifts that content from column `hi` to column `lo` on line `line`.
+*
+* Block structure is read off columns, so a line indented into that window
+* can change parents when the content moves: it sat left of the content
+* (a sibling or a parent's entry) and ends up at or right of it (a child),
+* or the reverse. Lines are scanned until the first one indented at or left
+* of `stop`, the column of the indicator that owns the construct, which
+* ends it. Blank and comment-only lines carry no structure and are skipped.
+*/
+function laterLineInWindow(ctx, line, stop, lo, hi) {
+	for (let n = line + 1; n < ctx.lines.length; n++) {
+		const text = ctx.lines[n].text;
+		let indent = 0;
+		while (indent < text.length && text[indent] === " ") indent++;
+		if (indent === text.length || text[indent] === "#") continue;
+		if (indent <= stop) return false;
+		if (indent >= lo && indent <= hi) return true;
+	}
+	return false;
+}
 
-export { coveringToken, insideScalarSpan, isScalarContinuationLine, nonNegativeIntegerOption, positionAt, positiveIntegerOption, walkScalars };
+export { composedScalars, coveringToken, endsWithLineBreak, insideComposedScalar, insideScalarSpan, isScalarContinuationLine, laterLineInWindow, nonNegativeIntegerOption, positionAt, positiveIntegerOption, walkScalars };

package/package.json

@@ -1,8 +1,8 @@
 {
 	"name": "@effected/yaml",
-	"version": "0.25.0",
+	"version": "0.26.0",
 	"private": false,
-	"description": "Zero-dependency YAML parsing, editing, formatting and linting as Effect schemas.",
+	"description": "YAML parsing, editing, formatting and linting as Effect schemas, with no IO and no dependency beyond effect and the kit's own position helpers.",
 	"keywords": [
 		"yaml",
 		"parser",
@@ -40,6 +40,9 @@
 		},
 		"./package.json": "./package.json"
 	},
+	"dependencies": {
+		"@effected/source": "^0.1.0"
+	},
 	"peerDependencies": {
 		"effect": "^4.0.0"
 	},

package/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.59.1"
+      "packageVersion": "7.59.4"
     }
   ]
 }