@effected/yaml 0.7.0 → 0.8.0

package/internal/fold.js

@@ -174,12 +174,18 @@ function renderSingleQuotedMultiline(s, indent) {
 * @param explicitChomp - Original chomp indicator from the AST, when known.
 * `keep` (`+`) and `strip` (`-`) preserve trailing-newline semantics that
 * cannot be inferred from the resolved value alone.
+* @param preserveKeep - Re-emit a REDUNDANT explicit `+` (a keep header whose
+* value ends in exactly one newline, where clip would read identically) —
+* fidelity-path header preservation; canonical mode passes false.
+* @param explicitIndent - Explicit indentation-indicator digit from the AST,
+* re-emitted only when it matches the rendered indent (fidelity path).
 */
-function renderBlockLiteral(s, indent, explicitChomp, parentPosition) {
+function renderBlockLiteral(s, indent, explicitChomp, parentPosition, preserveKeep = false, explicitIndent) {
 	let chomp = "";
 	const onlyNewlines = s.length > 0 && /^\n+$/.test(s);
 	if (s.endsWith("\n\n") || onlyNewlines && explicitChomp === "keep") chomp = "+";
 	else if (!s.endsWith("\n")) chomp = "-";
+	else if (preserveKeep && explicitChomp === "keep") chomp = "+";
 	const lines = s.split("\n");
 	if (s.endsWith("\n")) lines.pop();
 	let indentIndicator = "";
@@ -187,6 +193,7 @@ function renderBlockLiteral(s, indent, explicitChomp, parentPosition) {
 	const hasContent = firstContent !== void 0;
 	if (firstContent?.startsWith(" ") || lines.length > 0 && lines[0] === "" && hasContent) indentIndicator = String(indent.length);
 	else if (!hasContent && chomp === "+" && parentPosition === "block-map-value" && indent.length > 0) indentIndicator = String(indent.length);
+	else if (explicitIndent !== void 0 && explicitIndent === indent.length) indentIndicator = String(explicitIndent);
 	return `|${indentIndicator}${chomp}\n${lines.map((l) => l === "" ? "" : `${indent}${l}`).join("\n")}`;
 }
 /**
@@ -197,34 +204,39 @@ function renderBlockLiteral(s, indent, explicitChomp, parentPosition) {
 * the output must contain an empty line (double newline). Each empty line
 * in the value already produces the correct number of blank lines.
 */
-function renderBlockFolded(s, indent) {
+function renderBlockFolded(s, indent, explicitChomp, explicitIndent) {
 	let chomp = "";
 	if (s.endsWith("\n\n")) chomp = "+";
 	else if (!s.endsWith("\n")) chomp = "-";
+	else if (explicitChomp === "keep") chomp = "+";
 	const valueLines = s.split("\n");
 	if (s.endsWith("\n")) valueLines.pop();
 	let indentIndicator = "";
 	const firstContent = valueLines.find((l) => l !== "");
 	if (firstContent?.startsWith(" ") || valueLines.length >= 2 && valueLines[0] === "" && valueLines[1] === "" && firstContent !== void 0) indentIndicator = String(indent.length);
+	else if (explicitIndent !== void 0 && explicitIndent === indent.length) indentIndicator = String(explicitIndent);
 	const outputLines = [];
+	let lastContentIdx = -1;
+	for (let i = valueLines.length - 1; i >= 0; i--) if (valueLines[i] !== "") {
+		lastContentIdx = i;
+		break;
+	}
 	let prevNonEmpty = false;
 	let prevMoreIndented = false;
+	let pendingCompensation = false;
 	for (let i = 0; i < valueLines.length; i++) {
 		const line = valueLines[i];
 		if (line === "") {
-			if (prevNonEmpty && !prevMoreIndented) {
-				let nextContentMoreIndented = false;
-				for (let j = i + 1; j < valueLines.length; j++) if (valueLines[j] !== "") {
-					nextContentMoreIndented = valueLines[j].startsWith(" ") || valueLines[j].startsWith("	");
-					break;
-				}
-				if (!nextContentMoreIndented) outputLines.push("");
-			}
+			if (prevNonEmpty && !prevMoreIndented && i < lastContentIdx) pendingCompensation = true;
 			outputLines.push("");
 			prevNonEmpty = false;
 			prevMoreIndented = false;
 		} else {
 			const isMoreIndented = line.startsWith(" ") || line.startsWith("	");
+			if (pendingCompensation) {
+				if (!isMoreIndented) outputLines.push("");
+				pendingCompensation = false;
+			}
 			if (prevNonEmpty && !isMoreIndented) outputLines.push("");
 			outputLines.push(`${indent}${line}`);
 			prevNonEmpty = true;

package/internal/rules/catalog.js

@@ -0,0 +1,39 @@
+import { colonSpacing, colonSpacingOptions } from "./colon-spacing.js";
+import { commentsSpacing, commentsSpacingOptions } from "./comments-spacing.js";
+import { documentEnd, documentEndOptions } from "./document-end.js";
+import { documentStart, documentStartOptions } from "./document-start.js";
+import { emptyLines, emptyLinesOptions } from "./empty-lines.js";
+import { eofNewline, eofNewlineOptions } from "./eof-newline.js";
+import { hyphenSpacing, hyphenSpacingOptions } from "./hyphen-spacing.js";
+import { indentation, indentationOptions } from "./indentation.js";
+import { keyDuplicates, keyDuplicatesOptions } from "./key-duplicates.js";
+import { lineLength, lineLengthOptions } from "./line-length.js";
+import { parseValidity, parseValidityOptions } from "./parse-validity.js";
+import { quotedStrings, quotedStringsOptions } from "./quoted-strings.js";
+import { trailingSpaces, trailingSpacesOptions } from "./trailing-spaces.js";
+import { truthy, truthyOptions } from "./truthy.js";
+
+//#region src/internal/rules/catalog.ts
+const catalog = [
+	[parseValidity, parseValidityOptions],
+	[lineLength, lineLengthOptions],
+	[trailingSpaces, trailingSpacesOptions],
+	[emptyLines, emptyLinesOptions],
+	[eofNewline, eofNewlineOptions],
+	[documentStart, documentStartOptions],
+	[documentEnd, documentEndOptions],
+	[keyDuplicates, keyDuplicatesOptions],
+	[quotedStrings, quotedStringsOptions],
+	[truthy, truthyOptions],
+	[commentsSpacing, commentsSpacingOptions],
+	[colonSpacing, colonSpacingOptions],
+	[hyphenSpacing, hyphenSpacingOptions],
+	[indentation, indentationOptions]
+];
+/** The built-in rules, in catalog order (parse-validity is rule `#1`). */
+const builtinRules = catalog.map(([rule]) => rule);
+/** Per-rule options schemas — the rule-aware half of config validation. */
+const builtinOptionsSchemas = new Map(catalog.map(([rule, options]) => [rule.id, options]));
+
+//#endregion
+export { builtinOptionsSchemas, builtinRules };

package/internal/rules/colon-spacing.js

@@ -0,0 +1,77 @@
+import { YamlEdit } from "../../YamlEdit.js";
+import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { nonNegativeIntegerOption, positiveIntegerOption } from "./util.js";
+import { Schema } from "effect";
+
+//#region src/internal/rules/colon-spacing.ts
+/**
+* Options for `colon-spacing`: `maxSpacesBefore` (default 0) and
+* `maxSpacesAfter` (default 1) around the `:` indicator. `maxSpacesBefore: 0`
+* is legal (`key:` needs no space before the colon), but at least one
+* separation space must FOLLOW it — `0` would make the fix emit `a:val`, a
+* plain scalar, not a mapping entry.
+*/
+const colonSpacingOptions = Schema.Struct({
+	severity: Schema.optionalKey(YamlLintSeverity),
+	maxSpacesBefore: Schema.optionalKey(nonNegativeIntegerOption),
+	maxSpacesAfter: Schema.optionalKey(positiveIntegerOption)
+});
+/** Spacing around the block-mapping `:` indicator. */
+const colonSpacing = {
+	id: "colon-spacing",
+	check: (ctx, options) => {
+		const opts = options ?? {};
+		const maxBefore = opts.maxSpacesBefore ?? 0;
+		const maxAfter = Math.max(1, opts.maxSpacesAfter ?? 1);
+		const out = [];
+		for (const token of ctx.tokens) {
+			if (token.kind !== "block-map-value") 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: ""
+				})
+			}));
+			let j = token.offset + token.length;
+			let after = 0;
+			while (j < ctx.text.length && ctx.text[j] === " ") {
+				after++;
+				j++;
+			}
+			const next = ctx.text[j];
+			if (next === void 0 || next === "\n" || next === "\r" || next === "#") continue;
+			if (after > maxAfter) out.push(new YamlLintDiagnostic({
+				rule: "colon-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({
+					offset: token.offset + token.length,
+					length: after - maxAfter,
+					content: ""
+				})
+			}));
+		}
+		return out;
+	}
+};
+
+//#endregion
+export { colonSpacing, colonSpacingOptions };

package/internal/rules/comments-spacing.js

@@ -0,0 +1,68 @@
+import { YamlEdit } from "../../YamlEdit.js";
+import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { nonNegativeIntegerOption } from "./util.js";
+import { Schema } from "effect";
+
+//#region src/internal/rules/comments-spacing.ts
+/**
+* Options for `comments-spacing`: `minSpacesBefore` between content and a
+* trailing `#` (default 1 — the kit's own emission spelling) and
+* `requireSpaceAfter` the `#` (default `true`).
+*/
+const commentsSpacingOptions = Schema.Struct({
+	severity: Schema.optionalKey(YamlLintSeverity),
+	minSpacesBefore: Schema.optionalKey(nonNegativeIntegerOption),
+	requireSpaceAfter: Schema.optionalKey(Schema.Boolean)
+});
+/** Comment spacing: after the `#`, and before a trailing comment's `#`. */
+const commentsSpacing = {
+	id: "comments-spacing",
+	check: (ctx, options) => {
+		const opts = options ?? {};
+		const minBefore = opts.minSpacesBefore ?? 1;
+		const requireAfter = opts.requireSpaceAfter ?? true;
+		const out = [];
+		for (const token of ctx.tokens) {
+			if (token.kind !== "comment") continue;
+			if (token.offset === 0 && token.text.startsWith("#!")) continue;
+			if (requireAfter && token.text.length > 1 && !/[ \t]/.test(token.text[1])) out.push(new YamlLintDiagnostic({
+				rule: "comments-spacing",
+				severity: "error",
+				message: "Missing space after \"#\"",
+				offset: token.offset,
+				length: 1,
+				line: token.line,
+				character: token.character,
+				fix: YamlEdit.make({
+					offset: token.offset + 1,
+					length: 0,
+					content: " "
+				})
+			}));
+			let i = token.offset - 1;
+			let spaces = 0;
+			while (i >= 0 && (ctx.text[i] === " " || ctx.text[i] === "	")) {
+				spaces++;
+				i--;
+			}
+			if (i >= 0 && ctx.text[i] !== "\n" && ctx.text[i] !== "\r" && spaces < minBefore) out.push(new YamlLintDiagnostic({
+				rule: "comments-spacing",
+				severity: "error",
+				message: `Too few spaces before comment (${spaces} < ${minBefore})`,
+				offset: token.offset - spaces,
+				length: spaces,
+				line: token.line,
+				character: token.character - spaces,
+				fix: YamlEdit.make({
+					offset: token.offset,
+					length: 0,
+					content: " ".repeat(minBefore - spaces)
+				})
+			}));
+		}
+		return out;
+	}
+};
+
+//#endregion
+export { commentsSpacing, commentsSpacingOptions };

package/internal/rules/document-end.js

@@ -0,0 +1,65 @@
+import { YamlEdit } from "../../YamlEdit.js";
+import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { Schema } from "effect";
+
+//#region src/internal/rules/document-end.ts
+/** Options for `document-end`: require (`true`, default) or forbid the marker. */
+const documentEndOptions = Schema.Struct({
+	severity: Schema.optionalKey(YamlLintSeverity),
+	present: Schema.optionalKey(Schema.Boolean)
+});
+const TRIVIA = /* @__PURE__ */ new Set([
+	"newline",
+	"whitespace",
+	"comment",
+	"byte-order-mark"
+]);
+/** The `...` marker at the tail of the stream. */
+const documentEnd = {
+	id: "document-end",
+	check: (ctx, options) => {
+		const present = options?.present ?? true;
+		const tail = [...ctx.tokens].reverse().find((t) => !TRIVIA.has(t.kind));
+		const ended = tail?.kind === "document-end";
+		if (present && !ended && ctx.text.trim() !== "") {
+			const lastLine = ctx.lines[ctx.lines.length - 1];
+			const trailingNewline = ctx.text.endsWith("\n");
+			return [new YamlLintDiagnostic({
+				rule: "document-end",
+				severity: "error",
+				message: "Missing \"...\" document end marker",
+				offset: ctx.text.length,
+				length: 0,
+				line: (lastLine?.number ?? 0) + (trailingNewline ? 1 : 0),
+				character: trailingNewline ? 0 : lastLine?.text.length ?? 0,
+				fix: YamlEdit.make({
+					offset: ctx.text.length,
+					length: 0,
+					content: ctx.text.endsWith("\n") ? "...\n" : "\n...\n"
+				})
+			})];
+		}
+		if (!present && tail !== void 0 && tail.kind === "document-end") {
+			const alone = (ctx.lines[tail.line]?.text ?? "").trim() === "...";
+			const terminator = ctx.text.startsWith("\r\n", tail.offset + tail.length) ? 2 : 1;
+			return [new YamlLintDiagnostic({
+				rule: "document-end",
+				severity: "error",
+				message: "Forbidden \"...\" document end marker",
+				offset: tail.offset,
+				length: tail.length,
+				line: tail.line,
+				character: tail.character,
+				...alone ? { fix: YamlEdit.make({
+					offset: tail.offset,
+					length: tail.length + terminator,
+					content: ""
+				}) } : {}
+			})];
+		}
+		return [];
+	}
+};
+
+//#endregion
+export { documentEnd, documentEndOptions };

package/internal/rules/document-start.js

@@ -0,0 +1,64 @@
+import { YamlEdit } from "../../YamlEdit.js";
+import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { Schema } from "effect";
+
+//#region src/internal/rules/document-start.ts
+/** Options for `document-start`: require (`true`, default) or forbid the marker. */
+const documentStartOptions = Schema.Struct({
+	severity: Schema.optionalKey(YamlLintSeverity),
+	present: Schema.optionalKey(Schema.Boolean)
+});
+const TRIVIA = /* @__PURE__ */ new Set([
+	"newline",
+	"whitespace",
+	"comment",
+	"byte-order-mark",
+	"directive"
+]);
+/** The `---` marker at the head of the stream. */
+const documentStart = {
+	id: "document-start",
+	check: (ctx, options) => {
+		const present = options?.present ?? true;
+		const hasDirectives = ctx.tokens.some((t) => t.kind === "directive");
+		const first = ctx.tokens.find((t) => !TRIVIA.has(t.kind));
+		const headed = first?.kind === "document-start";
+		if (present && !headed && ctx.text.trim() !== "") return [new YamlLintDiagnostic({
+			rule: "document-start",
+			severity: "error",
+			message: "Missing \"---\" document start marker",
+			offset: 0,
+			length: 0,
+			line: 0,
+			character: 0,
+			...hasDirectives ? {} : { fix: YamlEdit.make({
+				offset: 0,
+				length: 0,
+				content: "---\n"
+			}) }
+		})];
+		if (!present && headed && first !== void 0) {
+			const lineText = ctx.lines[first.line]?.text ?? "";
+			const alone = !hasDirectives && lineText.trim() === "---";
+			const terminator = ctx.text.startsWith("\r\n", first.offset + first.length) ? 2 : 1;
+			return [new YamlLintDiagnostic({
+				rule: "document-start",
+				severity: "error",
+				message: "Forbidden \"---\" document start marker",
+				offset: first.offset,
+				length: first.length,
+				line: first.line,
+				character: first.character,
+				...alone ? { fix: YamlEdit.make({
+					offset: first.offset,
+					length: first.length + terminator,
+					content: ""
+				}) } : {}
+			})];
+		}
+		return [];
+	}
+};
+
+//#endregion
+export { documentStart, documentStartOptions };

package/internal/rules/empty-lines.js

@@ -0,0 +1,70 @@
+import { YamlEdit } from "../../YamlEdit.js";
+import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { insideScalarSpan, nonNegativeIntegerOption } from "./util.js";
+import { Schema } from "effect";
+
+//#region src/internal/rules/empty-lines.ts
+/**
+* Options for `empty-lines`: `max` consecutive blank lines in the body
+* (default 2), `maxStart` at the document start and `maxEnd` at the end
+* (both default 0).
+*/
+const emptyLinesOptions = Schema.Struct({
+	severity: Schema.optionalKey(YamlLintSeverity),
+	max: Schema.optionalKey(nonNegativeIntegerOption),
+	maxStart: Schema.optionalKey(nonNegativeIntegerOption),
+	maxEnd: Schema.optionalKey(nonNegativeIntegerOption)
+});
+/** Runs of blank lines beyond the configured caps, with a deleting fix. */
+const emptyLines = {
+	id: "empty-lines",
+	check: (ctx, options) => {
+		const opts = options ?? {};
+		const max = opts.max ?? 2;
+		const maxStart = opts.maxStart ?? 0;
+		const maxEnd = opts.maxEnd ?? 0;
+		const out = [];
+		const lines = ctx.lines;
+		let i = 0;
+		while (i < lines.length) {
+			const line = lines[i];
+			if (line === void 0 || line.text !== "" || insideScalarSpan(ctx.tokens, line.offset)) {
+				i++;
+				continue;
+			}
+			let end = i;
+			while (end < lines.length && (lines[end]?.text ?? "x") === "") end++;
+			const runLength = end - i;
+			const atStart = i === 0;
+			const atEnd = end === lines.length;
+			const allowed = atStart ? maxStart : atEnd ? maxEnd : max;
+			if (runLength > allowed) {
+				const firstExcess = lines[i + allowed];
+				const lastBlank = lines[end - 1];
+				if (firstExcess !== void 0 && lastBlank !== void 0) {
+					const nextLine = lines[end];
+					const deleteEnd = nextLine !== void 0 ? nextLine.offset : ctx.text.length;
+					out.push(new YamlLintDiagnostic({
+						rule: "empty-lines",
+						severity: "error",
+						message: `Too many consecutive blank lines (${runLength} > ${allowed})`,
+						offset: firstExcess.offset,
+						length: deleteEnd - firstExcess.offset,
+						line: firstExcess.number,
+						character: 0,
+						fix: YamlEdit.make({
+							offset: firstExcess.offset,
+							length: deleteEnd - firstExcess.offset,
+							content: ""
+						})
+					}));
+				}
+			}
+			i = end;
+		}
+		return out;
+	}
+};
+
+//#endregion
+export { emptyLines, emptyLinesOptions };

package/internal/rules/eof-newline.js

@@ -0,0 +1,33 @@
+import { YamlEdit } from "../../YamlEdit.js";
+import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { Schema } from "effect";
+
+//#region src/internal/rules/eof-newline.ts
+/** Options for `eof-newline` (severity only — nothing to tune). */
+const eofNewlineOptions = Schema.Struct({ severity: Schema.optionalKey(YamlLintSeverity) });
+/** A missing final newline, with an inserting fix. */
+const eofNewline = {
+	id: "eof-newline",
+	check: (ctx) => {
+		if (ctx.text.length === 0 || ctx.text.endsWith("\n")) return [];
+		const lastLine = ctx.lines[ctx.lines.length - 1];
+		if (lastLine === void 0) return [];
+		return [new YamlLintDiagnostic({
+			rule: "eof-newline",
+			severity: "error",
+			message: "No newline at end of file",
+			offset: ctx.text.length,
+			length: 0,
+			line: lastLine.number,
+			character: lastLine.text.length,
+			fix: YamlEdit.make({
+				offset: ctx.text.length,
+				length: 0,
+				content: "\n"
+			})
+		})];
+	}
+};
+
+//#endregion
+export { eofNewline, eofNewlineOptions };

package/internal/rules/hyphen-spacing.js

@@ -0,0 +1,52 @@
+import { YamlEdit } from "../../YamlEdit.js";
+import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { positiveIntegerOption } from "./util.js";
+import { Schema } from "effect";
+
+//#region src/internal/rules/hyphen-spacing.ts
+/**
+* Options for `hyphen-spacing`: `maxSpacesAfter` (default 1) after the `-`.
+* At least one separation space must follow the indicator — `0` would make
+* the fix emit `-item`, a plain scalar, not a sequence entry.
+*/
+const hyphenSpacingOptions = Schema.Struct({
+	severity: Schema.optionalKey(YamlLintSeverity),
+	maxSpacesAfter: Schema.optionalKey(positiveIntegerOption)
+});
+/** Spacing after the block-sequence `-` indicator. */
+const hyphenSpacing = {
+	id: "hyphen-spacing",
+	check: (ctx, options) => {
+		const maxAfter = Math.max(1, (options ?? {}).maxSpacesAfter ?? 1);
+		const out = [];
+		for (const token of ctx.tokens) {
+			if (token.kind !== "block-seq-entry") continue;
+			let j = token.offset + token.length;
+			let after = 0;
+			while (j < ctx.text.length && ctx.text[j] === " ") {
+				after++;
+				j++;
+			}
+			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({
+					offset: token.offset + token.length,
+					length: after - maxAfter,
+					content: ""
+				})
+			}));
+		}
+		return out;
+	}
+};
+
+//#endregion
+export { hyphenSpacing, hyphenSpacingOptions };

package/internal/rules/indentation.js

@@ -0,0 +1,103 @@
+import { YamlLintDiagnostic, YamlLintSeverity } from "../../YamlLintRule.js";
+import { coveringToken, isScalarContinuationLine, nonNegativeIntegerOption } from "./util.js";
+import { Schema } from "effect";
+
+//#region src/internal/rules/indentation.ts
+/**
+* Options for `indentation`: `spaces` per level (number or "consistent",
+* default "consistent") and `indentSequences` (boolean or "consistent",
+* default "consistent").
+*/
+const indentationOptions = Schema.Struct({
+	severity: Schema.optionalKey(YamlLintSeverity),
+	spaces: Schema.optionalKey(Schema.Union([nonNegativeIntegerOption, Schema.Literals(["consistent"])])),
+	indentSequences: Schema.optionalKey(Schema.Union([Schema.Boolean, Schema.Literals(["consistent"])]))
+});
+/** Flow-collection depth at each line start, from the token stream. */
+const flowDepthAtLineStarts = (ctx) => {
+	const depths = [];
+	let depth = 0;
+	let tokenIdx = 0;
+	for (const line of ctx.lines) {
+		while (tokenIdx < ctx.tokens.length) {
+			const token = ctx.tokens[tokenIdx];
+			if (token === void 0 || token.offset + token.length > line.offset) break;
+			if (token.kind === "flow-map-start" || token.kind === "flow-seq-start") depth++;
+			if (token.kind === "flow-map-end" || token.kind === "flow-seq-end") depth = Math.max(0, depth - 1);
+			tokenIdx++;
+		}
+		depths.push(depth);
+	}
+	return depths;
+};
+/** Block-structure indent style. */
+const indentation = {
+	id: "indentation",
+	check: (ctx, options) => {
+		const opts = options ?? {};
+		const spacesOpt = opts.spaces ?? "consistent";
+		const seqOpt = opts.indentSequences ?? "consistent";
+		const out = [];
+		const flowDepths = flowDepthAtLineStarts(ctx);
+		const content = [];
+		for (const line of ctx.lines) {
+			const indent = line.text.length - line.text.trimStart().length;
+			const firstChar = line.text[indent];
+			if (firstChar === void 0) continue;
+			if (firstChar === "#") continue;
+			if (firstChar === "%") continue;
+			if (line.text.slice(0, indent).includes("	")) continue;
+			if ((flowDepths[line.number] ?? 0) > 0) continue;
+			if (isScalarContinuationLine(ctx.tokens, line.offset, line.offset + indent)) continue;
+			if (line.text.slice(indent).startsWith("---") || line.text.slice(indent).startsWith("...")) continue;
+			content.push({
+				line,
+				indent,
+				firstChar
+			});
+		}
+		let unit = typeof spacesOpt === "number" ? spacesOpt : void 0;
+		const stack = [0];
+		for (const { line, indent } of content) {
+			const top = stack[stack.length - 1];
+			if (indent > top) {
+				const delta = indent - top;
+				if (unit === void 0) unit = delta;
+				else if (delta !== unit) out.push(new YamlLintDiagnostic({
+					rule: "indentation",
+					severity: "error",
+					message: `Indent of ${delta} spaces, expected ${unit}`,
+					offset: line.offset,
+					length: indent,
+					line: line.number,
+					character: 0
+				}));
+				stack.push(indent);
+			} else if (indent < top) while (stack.length > 1 && stack[stack.length - 1] > indent) stack.pop();
+		}
+		let seqIndented = typeof seqOpt === "boolean" ? seqOpt : void 0;
+		for (let i = 1; i < content.length; i++) {
+			const prev = content[i - 1];
+			const curr = content[i];
+			if (curr.firstChar !== "-") continue;
+			if (coveringToken(ctx.tokens, curr.line.offset + curr.indent)?.kind !== "block-seq-entry") continue;
+			if (!prev.line.text.replace(/ #.*$/, "").trimEnd().endsWith(":")) continue;
+			if (curr.indent !== prev.indent && curr.indent !== prev.indent + (unit ?? curr.indent - prev.indent)) continue;
+			const indented = curr.indent > prev.indent;
+			if (seqIndented === void 0) seqIndented = indented;
+			else if (indented !== seqIndented) out.push(new YamlLintDiagnostic({
+				rule: "indentation",
+				severity: "error",
+				message: seqIndented ? "Sequence under a mapping key should be indented" : "Sequence under a mapping key should not be indented",
+				offset: curr.line.offset,
+				length: curr.indent,
+				line: curr.line.number,
+				character: 0
+			}));
+		}
+		return out;
+	}
+};
+
+//#endregion
+export { indentation, indentationOptions };