@limaformat/lima 0.8.0 → 0.8.1

package/dist/block.js

@@ -11,20 +11,12 @@
 import { checkKeyLength, checkDuplicateKey, NESTING_DEPTH_LIMIT } from './normalize.js';
 import { stripKeyQuotes, stripComment, stripCommentKeepEscapes, parseQuotedOrTyped, closingQuoteIndex, isValidKey, } from './scalars.js';
 import { KEY_GRAMMAR_HINT, specificKeyHint } from './key-hints.js';
-import { parseFlowOrScalarValue, parseFlowSequence } from './flow.js';
+import { parseFlowOrScalarValue, parseFlowSequence, flowValueReader } from './flow.js';
 import { buildBlockScalar } from './block-scalar.js';
 import { LimaError, printableLine } from './errors.js';
 import { isTrimWhitespace } from './chars.js';
-import { BlockCursor } from './block-cursor.js';
+import { BlockCursor, SourceBlockCursor } from './block-cursor.js';
 const DASH_PREFIX_RE = /^-\s+/;
-/**
- * A key's inline value text. If it is exactly `|`, consume the following
- * physical lines belonging to the Core §6.1.5 block scalar introduced by a
- * key at `keyIndent` and return the scalar; the cursor is left on the first
- * line past the scalar. Otherwise parse `raw` as an ordinary inline value
- * and advance one line. §6.1.5 places no top-level restriction on block
- * scalars, so this is the same primitive `core.ts` uses at the top level.
- */
 /** Length of the `- ` (dash + whitespace) prefix on the cursor's current line. */
 const dashPrefixLen = (cursor) => {
     const start = cursor.contentStart, end = cursor.lineEnd;
@@ -49,24 +41,18 @@ const inlineSource = (wantSource, ctx, keyLine, valueCol, rawUndecoded) => wantS
     raw: physicalRaw(rawUndecoded), line: keyLine, col: valueCol,
     tabAdjust: ctx.tabAdjust ? [ctx.tabAdjust[keyLine - 1] ?? 0] : undefined,
 }) : undefined;
-/** An inline value, or a `|` block scalar when `marker`: the value is `|` alone (§6.1.5; `| # c` is the string `|`). */
-const inlineOrBlockScalar = (raw, marker, keyIndent, keyLine, valueCol, rawUndecoded, cursor, ctx, builder) => {
+/**
+ * An inline value, or a block scalar when `marker`: `|` alone (§6.1.5;
+ * `| # c` is the string `|`). Both leave the cursor on the next unread line.
+ */
+export const parseInlineValue = (raw, marker, keyIndent, keyLine, valueCol, rawUndecoded, cursor, ctx, builder, readValue) => {
     const wantSource = builder.positions === true;
     if (!marker) {
-        const value = parseFlowOrScalarValue(raw, ctx, keyLine, builder, inlineSource(wantSource, ctx, keyLine, valueCol, rawUndecoded));
+        const value = readValue(raw, ctx, keyLine, builder, inlineSource(wantSource, ctx, keyLine, valueCol, rawUndecoded), cursor.lineStart + valueCol);
         cursor.next();
         return value;
     }
-    cursor.next(); // past the `key: |` line
-    const bodyLines = [];
-    while (cursor.valid) {
-        // the scalar's own extent (§6.1.5, `buildBlockScalar`): a line of spaces only is empty, any other ends it at the
-        // key's column or less — a line of other whitespace too, which is content here
-        if (cursor.lineEnd - cursor.lineStart > cursor.asciiIndent && cursor.asciiIndent <= keyIndent)
-            break;
-        bodyLines.push(cursor.source.slice(cursor.lineStart, cursor.lineEnd));
-        cursor.next();
-    }
+    const bodyLines = cursor.scalarLines(keyIndent);
     return buildBlockScalar(bodyLines, keyIndent, keyLine, ctx, builder).value;
 };
 export const findKeySep = (s) => {
@@ -82,11 +68,6 @@ export const findKeySep = (s) => {
     }
     return s.indexOf(': ');
 };
-/**
- * Recursively parses a block value from a mutable physical-line cursor over
- * the original source. Strings are materialized only when grammar or scalar
- * parsing needs their content.
- */
 /**
  * `source.slice(start, end).trimEnd()`: a key, or a line's content, keeps the whitespace it starts with, which makes it
  * no key (Core 1.1 §7.1: other whitespace before content is no indentation).
@@ -138,20 +119,6 @@ const isSequenceItem = (cursor) => {
     const next = cursor.contentStart + 1;
     return next === cursor.lineEnd || isTrimWhitespace(cursor.source.charCodeAt(next));
 };
-/**
- * Core 1.1 §7.2: the block of a bare key at `keyColumn` — deeper than the key (§7.1 rule 3), or a sequence that
- * starts at the key's own column, which `compact` parsing ends at that column's first line that is no item. Null
- * without either. The cursor is on the first content line after the key.
- */
-const blockOfBareKey = (cursor, keyColumn, ctx, baseLine, builder) => {
-    if (!cursor.valid)
-        return null;
-    if (cursor.indent > keyColumn)
-        return parseCursorBlock(cursor, cursor.indent, ctx, baseLine, builder);
-    if (cursor.indent === keyColumn && isSequenceItem(cursor))
-        return parseCursorBlock(cursor, keyColumn, ctx, baseLine, builder, true);
-    return null;
-};
 const cursorAfterDash = (cursor) => {
     const start = cursor.contentStart;
     const end = cursor.lineEnd;
@@ -169,40 +136,263 @@ const unrecognizedKeyLine = (line, trimmed) => new LimaError({
     code: 'UNRECOGNIZED_LINE', line,
     message: `Lima: unrecognised line at line ${line}: "${printableLine(trimmed)}"${specificKeyHint(trimmed) ?? KEY_GRAMMAR_HINT}`,
 });
-/** Shared block grammar consuming one mutable physical-line cursor. */
-export const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder, compact = false) => {
-    const wantSource = builder.positions === true;
-    let items = null;
-    let entries = null;
-    let pendingItem = null;
-    // the column of the pending object item's keys: its first key's, after `- ` (§7.2)
-    let pendingColumn = 0;
-    const startLine = cursor.lineIndex;
-    while (cursor.valid) {
-        const line = baseLine + cursor.lineIndex;
-        if (cursor.empty || cursor.firstCode === 35) {
-            cursor.next();
-            continue;
-        }
-        const indent = cursor.indent;
-        if (indent < baseIndent)
-            break;
-        if (indent > baseIndent) {
-            const trimmed = cursorContent(cursor);
-            // §7.2: an object item's keys stand at its first key's column. A line less indented ends the item (§7.1
-            // rule 4); a deeper one, which no nested block took, is inconsistently indented (rule 5) and the item goes on
-            if (pendingItem !== null && indent < pendingColumn) {
-                items.push(builder.mapping(pendingItem, line));
-                pendingItem = null;
-            }
-            if (pendingItem !== null && indent > pendingColumn) {
-                if (ctx.strict)
-                    throw new LimaError({ code: 'INVALID_INDENTATION', line,
-                        message: `Lima: unexpected indentation at line ${line}: "${trimmed}"` });
+const sourceKeyReader = (cursor, positions) => {
+    if (!(cursor instanceof SourceBlockCursor))
+        throw new Error('Lima: source positions require a source block cursor');
+    return (raw, strict, line, colon, prefix = 0, requireNonempty = false) => {
+        const key = stripKeyQuotes(raw, strict, line);
+        if (requireNonempty && !key)
+            return key;
+        const start = cursor.contentStart + prefix;
+        const separator = start + colon;
+        // Core §4 / §15.4: the physical colon must precede a space or end the
+        // line/input. Comment stripping can make `- name:# unfinished` look
+        // like a bare key, so its parsed colon alone is insufficient.
+        const readable = separator === cursor.lineEnd - 1 || cursor.source.charCodeAt(separator + 1) === 32;
+        positions.key(key, start, readable ? start + raw.length : start, separator, line);
+        cursor.excludeCommentsBefore(separator + 1);
+        return key;
+    };
+};
+const sourceSequenceReader = (positions) => (raw, ctx, line, builder, _source, offset) => positions.recover(() => parseFlowSequence(raw, ctx, line, builder, undefined, offset), null);
+/** Bind reporting outside the grammar, once for the entire recursive block. */
+const blockParser = (readKey, uncomment, readValue, readSequence) => {
+    /**
+     * Core 1.1 §7.2: the block of a bare key at `keyColumn` — deeper than the key (§7.1 rule 3), or a sequence that
+     * starts at the key's own column, which `compact` parsing ends at that column's first line that is no item. Null
+     * without either. The cursor is on the first content line after the key.
+     */
+    const blockOfBareKey = (cursor, keyColumn, ctx, baseLine, builder) => {
+        if (!cursor.valid)
+            return null;
+        if (cursor.indent > keyColumn)
+            return parseCursorBlock(cursor, cursor.indent, ctx, baseLine, builder);
+        if (cursor.indent === keyColumn && isSequenceItem(cursor))
+            return parseCursorBlock(cursor, keyColumn, ctx, baseLine, builder, true);
+        return null;
+    };
+    const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder, compact = false) => {
+        const wantSource = builder.positions === true;
+        let items = null;
+        let entries = null;
+        let pendingItem = null;
+        // the column of the pending object item's keys: its first key's, after `- ` (§7.2)
+        let pendingColumn = 0;
+        const startLine = cursor.lineIndex;
+        while (cursor.valid) {
+            const line = baseLine + cursor.lineIndex;
+            if (cursor.empty || cursor.firstCode === 35) {
                 cursor.next();
                 continue;
             }
-            if (items !== null && pendingItem !== null) {
+            const indent = cursor.indent;
+            if (indent < baseIndent)
+                break;
+            if (indent > baseIndent) {
+                const trimmed = cursorContent(cursor);
+                // §7.2: an object item's keys stand at its first key's column. A line less indented ends the item (§7.1
+                // rule 4); a deeper one, which no nested block took, is inconsistently indented (rule 5) and the item goes on
+                if (pendingItem !== null && indent < pendingColumn) {
+                    items.push(builder.mapping(pendingItem, line));
+                    pendingItem = null;
+                }
+                if (pendingItem !== null && indent > pendingColumn) {
+                    if (ctx.strict)
+                        throw new LimaError({ code: 'INVALID_INDENTATION', line,
+                            message: `Lima: unexpected indentation at line ${line}: "${trimmed}"` });
+                    cursor.next();
+                    continue;
+                }
+                if (items !== null && pendingItem !== null) {
+                    const bareKey = trimmed.charCodeAt(trimmed.length - 1) === 58;
+                    const colonPos = bareKey && trimmed.indexOf(' ') === -1 ? -1 : findKeySep(trimmed);
+                    const keyRaw = colonPos !== -1
+                        ? trimEndSlice(trimmed, 0, colonPos)
+                        : bareKey ? trimEndSlice(trimmed, 0, trimmed.length - 1) : '';
+                    if ((keyRaw !== '' || colonPos !== -1) && !isValidKey(keyRaw)) {
+                        // §5.1: not a usable key — an unrecognised line, skipped in non-strict mode and an error in strict
+                        // mode, as at the top level (Core 1.1 §10.1)
+                        if (ctx.strict)
+                            throw unrecognizedKeyLine(line, trimmed);
+                        cursor.next();
+                    }
+                    else if (colonPos !== -1) {
+                        const key = readKey(keyRaw, ctx.strict, line, colonPos);
+                        checkKeyLength(key, line);
+                        const rawUndecoded = trimSlice(trimmed, colonPos + 2, trimmed.length);
+                        let raw = rawUndecoded;
+                        if (raw !== '|' && raw.includes('#'))
+                            raw = uncomment(raw);
+                        const valueCol = wantSource ? cursor.indent + colonPos + 2 + leadingWsLen(trimmed.slice(colonPos + 2)) : 0;
+                        builder.setMapping(pendingItem, key, parseInlineValue(raw, rawUndecoded === '|', indent, line, valueCol, rawUndecoded, cursor, ctx, builder, readValue));
+                    }
+                    else if (bareKey) {
+                        const key = readKey(keyRaw, ctx.strict, line, trimmed.length - 1);
+                        checkKeyLength(key, line);
+                        cursor.next();
+                        skipEmptyAndCommentLines(cursor);
+                        const nested = blockOfBareKey(cursor, indent, ctx, baseLine, builder);
+                        builder.setMapping(pendingItem, key, nested ?? builder.null(line));
+                    }
+                    else {
+                        if (ctx.strict)
+                            throw new LimaError({ code: 'INVALID_INDENTATION', line,
+                                message: `Lima: unexpected syntax in array item continuation at line ${line}: "${trimmed}"` });
+                        cursor.next();
+                    }
+                }
+                else {
+                    if (ctx.strict)
+                        throw new LimaError({ code: 'INVALID_INDENTATION', line,
+                            message: `Lima: unexpected indentation at line ${line}: "${trimmed}"` });
+                    cursor.next();
+                }
+                continue;
+            }
+            // a sequence at its key's column ends at that column's first line that is no item (Core 1.1 §7.2)
+            if (compact && !isSequenceItem(cursor))
+                break;
+            if (isSequenceItem(cursor)) {
+                if (pendingItem !== null) {
+                    items.push(builder.mapping(pendingItem, line));
+                    pendingItem = null;
+                }
+                // a block is a mapping or a sequence, as its first line decides; in non-strict mode a line of the other kind
+                // is skipped, and what the block holds stays (Core 1.1 §7.1)
+                if (entries !== null) {
+                    if (ctx.strict)
+                        throw new LimaError({ code: 'INVALID_INDENTATION', line,
+                            message: `Lima: mixed array and map entries for the same key at line ${line}` });
+                    cursor.next();
+                    continue;
+                }
+                if (items === null)
+                    items = [];
+                const afterDashRaw = cursorAfterDash(cursor);
+                const afterDash = afterDashRaw.includes('#') ? uncomment(afterDashRaw) : afterDashRaw.trimEnd();
+                const afterDashCol = wantSource ? cursor.indent + dashPrefixLen(cursor) : 0;
+                const afterDashTab = wantSource && ctx.tabAdjust ? [ctx.tabAdjust[line - 1] ?? 0] : undefined;
+                const dashSource = wantSource ? ({
+                    raw: physicalRaw(afterDashRaw), line, col: afterDashCol, tabAdjust: afterDashTab,
+                }) : undefined;
+                const first = afterDash.charCodeAt(0);
+                // an item's value is an inline value (§15.3): a flow mapping, or what an unclosed one falls back to (§7.5); a
+                // flow sequence there is a sequence in a sequence (§7.2)
+                if (first === 123) {
+                    items.push(readValue(afterDash, ctx, line, builder, dashSource, cursor.contentStart + dashPrefixLen(cursor)));
+                    cursor.next();
+                    continue;
+                }
+                if (first === 91) {
+                    const sequence = readSequence(afterDash, ctx, line, builder, dashSource, cursor.contentStart + dashPrefixLen(cursor));
+                    if (sequence === null)
+                        items.push(readValue(afterDash, ctx, line, builder, dashSource, cursor.contentStart + dashPrefixLen(cursor)));
+                    else if (ctx.strict)
+                        throw new LimaError({ code: 'INVALID_FLOW_SYNTAX', line,
+                            message: `Lima: nested sequence at line ${line}: "${cursorContent(cursor)}"` });
+                    else
+                        items.push(builder.null(line));
+                    cursor.next();
+                    continue;
+                }
+                if (first !== 34 && first !== 39 && first !== 45 &&
+                    afterDash.indexOf(': ') === -1 && !afterDash.endsWith(':')) {
+                    items.push(parseQuotedOrTyped(afterDash, ctx, line, builder, dashSource));
+                    cursor.next();
+                    continue;
+                }
+                const colonPos = findKeySep(afterDash);
+                if (afterDash === '-' || DASH_PREFIX_RE.test(afterDash)) {
+                    if (ctx.strict)
+                        throw new LimaError({ code: 'INVALID_INDENTATION', line,
+                            message: `Lima: nested block sequence at line ${line}: "${cursorContent(cursor)}"` });
+                    items.push(builder.null(line));
+                    cursor.next();
+                    while (cursor.valid) {
+                        if (cursor.empty || cursor.source.charCodeAt(cursor.contentStart) === 35) {
+                            cursor.next();
+                            continue;
+                        }
+                        if (cursor.indent <= baseIndent)
+                            break;
+                        cursor.next();
+                    }
+                }
+                else if (colonPos !== -1 && isValidKey(trimSlice(afterDash, 0, colonPos))) {
+                    const keyRaw = trimSlice(afterDash, 0, colonPos);
+                    const key = readKey(keyRaw, ctx.strict, line, colonPos, dashPrefixLen(cursor));
+                    checkKeyLength(key, line);
+                    const valueStart = colonPos + 2;
+                    const valueFirst = afterDash.charCodeAt(valueStart);
+                    const valueLast = afterDash.charCodeAt(afterDash.length - 1);
+                    const raw = valueFirst > 0x20 && valueFirst < 0x7f && valueLast > 0x20 && valueLast < 0x7f
+                        ? afterDash.slice(valueStart) : trimSlice(afterDash, valueStart, afterDash.length);
+                    // The key sits after `- `, two columns past the dash.
+                    const valueCol = wantSource ? afterDashCol + valueStart + leadingWsLen(afterDash.slice(valueStart)) : 0;
+                    pendingColumn = cursor.indent + dashPrefixLen(cursor);
+                    pendingItem = builder.createMappingWith(key, parseInlineValue(raw, trimSlice(afterDashRaw, valueStart, afterDashRaw.length) === '|', pendingColumn, line, valueCol, wantSource ? trimSlice(afterDashRaw, valueStart, afterDashRaw.length) : raw, cursor, ctx, builder, readValue));
+                    // the item's later keys at its key column; any other line is the block loop's (§7.2)
+                    while (cursor.valid && cursor.indent === pendingColumn) {
+                        const continuationLine = baseLine + cursor.lineIndex;
+                        const ckeyIndent = cursor.asciiIndent;
+                        const cfirst = cursor.source.charCodeAt(cursor.contentStart);
+                        if (cfirst === 35)
+                            break;
+                        const contLine = trimEndSlice(cursor.source, cursor.contentStart, cursor.lineEnd);
+                        const csep = findKeySep(contLine);
+                        if (csep === -1)
+                            break;
+                        const ckeyRaw = trimEndSlice(contLine, 0, csep);
+                        if (!isValidKey(ckeyRaw))
+                            break;
+                        const ckey = readKey(ckeyRaw, ctx.strict, continuationLine, csep, 0, true);
+                        if (!ckey)
+                            break;
+                        checkKeyLength(ckey, continuationLine);
+                        const valueUndecoded = trimSlice(contLine, csep + 2, contLine.length);
+                        let value = valueUndecoded;
+                        if (value !== '|' && value.includes('#'))
+                            value = uncomment(value);
+                        // contLine starts exactly at contentStart (no leading trim), so
+                        // the value's column is the indent plus its offset in contLine.
+                        const cValueCol = wantSource ? cursor.indent + csep + 2 + leadingWsLen(contLine.slice(csep + 2)) : 0;
+                        builder.setMapping(pendingItem, ckey, parseInlineValue(value, valueUndecoded === '|', ckeyIndent, continuationLine, cValueCol, valueUndecoded, cursor, ctx, builder, readValue));
+                    }
+                }
+                else if (afterDash.endsWith(':') && isValidKey(trimSlice(afterDash, 0, afterDash.length - 1))) {
+                    const key = readKey(trimSlice(afterDash, 0, afterDash.length - 1), ctx.strict, line, afterDash.length - 1, dashPrefixLen(cursor));
+                    checkKeyLength(key, line);
+                    // §7.1 rule 3 / §7.2: sibling keys of an object item align at
+                    // the column of the first key *after* `- `; a nested block
+                    // must be indented deeper than that column, not merely deeper
+                    // than the item's dash. A line at the key's own column is the
+                    // next sibling key, so the bare key is `null`.
+                    let keyColumn = cursor.contentStart + 1;
+                    while (keyColumn < cursor.lineEnd && isTrimWhitespace(cursor.source.charCodeAt(keyColumn)))
+                        keyColumn++;
+                    keyColumn -= cursor.lineStart;
+                    cursor.next();
+                    skipEmptyAndCommentLines(cursor);
+                    const nested = blockOfBareKey(cursor, keyColumn, ctx, baseLine, builder);
+                    pendingColumn = keyColumn;
+                    pendingItem = builder.createMappingWith(key, nested ?? builder.null(line));
+                }
+                else {
+                    // A quoted-or-typed scalar item — parseQuotedOrTyped enforces
+                    // §10.1's unterminated / trailing-content strict checks.
+                    items.push(parseQuotedOrTyped(afterDash, ctx, line, builder, dashSource));
+                    cursor.next();
+                }
+            }
+            else {
+                const trimmed = cursorContent(cursor);
+                if (items !== null) {
+                    if (ctx.strict)
+                        throw new LimaError({ code: 'INVALID_INDENTATION', line,
+                            message: `Lima: mixed map and array entries for the same key at line ${line}` });
+                    cursor.next();
+                    continue;
+                }
                 const bareKey = trimmed.charCodeAt(trimmed.length - 1) === 58;
                 const colonPos = bareKey && trimmed.indexOf(' ') === -1 ? -1 : findKeySep(trimmed);
                 const keyRaw = colonPos !== -1
@@ -216,235 +406,56 @@ export const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder, com
                     cursor.next();
                 }
                 else if (colonPos !== -1) {
-                    const key = stripKeyQuotes(keyRaw, ctx.strict, line);
+                    if (entries === null)
+                        entries = builder.createMapping();
+                    const key = readKey(keyRaw, ctx.strict, line, colonPos);
                     checkKeyLength(key, line);
+                    if (ctx.strict || ctx.onWarning !== undefined)
+                        checkDuplicateKey(builder.hasMappingKey(entries, key), key, line, ctx);
                     const rawUndecoded = trimSlice(trimmed, colonPos + 2, trimmed.length);
                     let raw = rawUndecoded;
                     if (raw !== '|' && raw.includes('#'))
-                        raw = stripComment(raw);
+                        raw = uncomment(raw);
                     const valueCol = wantSource ? cursor.indent + colonPos + 2 + leadingWsLen(trimmed.slice(colonPos + 2)) : 0;
-                    builder.setMapping(pendingItem, key, inlineOrBlockScalar(raw, rawUndecoded === '|', indent, line, valueCol, rawUndecoded, cursor, ctx, builder));
+                    builder.setMapping(entries, key, parseInlineValue(raw, rawUndecoded === '|', baseIndent, line, valueCol, rawUndecoded, cursor, ctx, builder, readValue));
                 }
                 else if (bareKey) {
-                    const key = stripKeyQuotes(keyRaw, ctx.strict, line);
+                    if (entries === null)
+                        entries = builder.createMapping();
+                    const key = readKey(keyRaw, ctx.strict, line, trimmed.length - 1);
                     checkKeyLength(key, line);
+                    if (ctx.strict || ctx.onWarning !== undefined)
+                        checkDuplicateKey(builder.hasMappingKey(entries, key), key, line, ctx);
                     cursor.next();
                     skipEmptyAndCommentLines(cursor);
-                    const nested = blockOfBareKey(cursor, indent, ctx, baseLine, builder);
-                    builder.setMapping(pendingItem, key, nested ?? builder.null(line));
+                    const nested = blockOfBareKey(cursor, baseIndent, ctx, baseLine, builder);
+                    builder.setMapping(entries, key, nested ?? builder.null(line));
                 }
                 else {
                     if (ctx.strict)
                         throw new LimaError({ code: 'INVALID_INDENTATION', line,
-                            message: `Lima: unexpected syntax in array item continuation at line ${line}: "${trimmed}"` });
-                    cursor.next();
-                }
-            }
-            else {
-                if (ctx.strict)
-                    throw new LimaError({ code: 'INVALID_INDENTATION', line,
-                        message: `Lima: unexpected indentation at line ${line}: "${trimmed}"` });
-                cursor.next();
-            }
-            continue;
-        }
-        // a sequence at its key's column ends at that column's first line that is no item (Core 1.1 §7.2)
-        if (compact && !isSequenceItem(cursor))
-            break;
-        if (isSequenceItem(cursor)) {
-            if (pendingItem !== null) {
-                items.push(builder.mapping(pendingItem, line));
-                pendingItem = null;
-            }
-            // a block is a mapping or a sequence, as its first line decides; in non-strict mode a line of the other kind
-            // is skipped, and what the block holds stays (Core 1.1 §7.1)
-            if (entries !== null) {
-                if (ctx.strict)
-                    throw new LimaError({ code: 'INVALID_INDENTATION', line,
-                        message: `Lima: mixed array and map entries for the same key at line ${line}` });
-                cursor.next();
-                continue;
-            }
-            if (items === null)
-                items = [];
-            const afterDashRaw = cursorAfterDash(cursor);
-            const afterDash = afterDashRaw.includes('#') ? stripComment(afterDashRaw) : afterDashRaw.trimEnd();
-            const afterDashCol = wantSource ? cursor.indent + dashPrefixLen(cursor) : 0;
-            const afterDashTab = wantSource && ctx.tabAdjust ? [ctx.tabAdjust[line - 1] ?? 0] : undefined;
-            const dashSource = wantSource ? ({
-                raw: physicalRaw(afterDashRaw), line, col: afterDashCol, tabAdjust: afterDashTab,
-            }) : undefined;
-            const first = afterDash.charCodeAt(0);
-            // an item's value is an inline value (§15.3): a flow mapping, or what an unclosed one falls back to (§7.5); a
-            // flow sequence there is a sequence in a sequence (§7.2)
-            if (first === 123) {
-                items.push(parseFlowOrScalarValue(afterDash, ctx, line, builder, dashSource));
-                cursor.next();
-                continue;
-            }
-            if (first === 91) {
-                const sequence = parseFlowSequence(afterDash, ctx, line, builder, dashSource);
-                if (sequence === null)
-                    items.push(parseFlowOrScalarValue(afterDash, ctx, line, builder, dashSource));
-                else if (ctx.strict)
-                    throw new LimaError({ code: 'INVALID_FLOW_SYNTAX', line,
-                        message: `Lima: nested sequence at line ${line}: "${cursorContent(cursor)}"` });
-                else
-                    items.push(builder.null(line));
-                cursor.next();
-                continue;
-            }
-            if (first !== 34 && first !== 39 && first !== 45 &&
-                afterDash.indexOf(': ') === -1 && !afterDash.endsWith(':')) {
-                items.push(parseQuotedOrTyped(afterDash, ctx, line, builder, dashSource));
-                cursor.next();
-                continue;
-            }
-            const colonPos = findKeySep(afterDash);
-            if (afterDash === '-' || DASH_PREFIX_RE.test(afterDash)) {
-                if (ctx.strict)
-                    throw new LimaError({ code: 'INVALID_INDENTATION', line,
-                        message: `Lima: nested block sequence at line ${line}: "${cursorContent(cursor)}"` });
-                items.push(builder.null(line));
-                cursor.next();
-                while (cursor.valid) {
-                    if (cursor.empty || cursor.source.charCodeAt(cursor.contentStart) === 35) {
-                        cursor.next();
-                        continue;
-                    }
-                    if (cursor.indent <= baseIndent)
-                        break;
+                            message: `Lima: indented freetext without a block scalar marker at line ${line}: "${trimmed}"` });
                     cursor.next();
                 }
             }
-            else if (colonPos !== -1 && isValidKey(trimSlice(afterDash, 0, colonPos))) {
-                const keyRaw = trimSlice(afterDash, 0, colonPos);
-                const key = stripKeyQuotes(keyRaw, ctx.strict, line);
-                checkKeyLength(key, line);
-                const valueStart = colonPos + 2;
-                const valueFirst = afterDash.charCodeAt(valueStart);
-                const valueLast = afterDash.charCodeAt(afterDash.length - 1);
-                const raw = valueFirst > 0x20 && valueFirst < 0x7f && valueLast > 0x20 && valueLast < 0x7f
-                    ? afterDash.slice(valueStart) : trimSlice(afterDash, valueStart, afterDash.length);
-                // The key sits after `- `, two columns past the dash.
-                const valueCol = wantSource ? afterDashCol + valueStart + leadingWsLen(afterDash.slice(valueStart)) : 0;
-                pendingColumn = cursor.indent + dashPrefixLen(cursor);
-                pendingItem = builder.createMappingWith(key, inlineOrBlockScalar(raw, trimSlice(afterDashRaw, valueStart, afterDashRaw.length) === '|', pendingColumn, line, valueCol, wantSource ? trimSlice(afterDashRaw, valueStart, afterDashRaw.length) : raw, cursor, ctx, builder));
-                // the item's later keys at its key column; any other line is the block loop's (§7.2)
-                while (cursor.valid && cursor.indent === pendingColumn) {
-                    const continuationLine = baseLine + cursor.lineIndex;
-                    const ckeyIndent = cursor.asciiIndent;
-                    const cfirst = cursor.source.charCodeAt(cursor.contentStart);
-                    if (cfirst === 35)
-                        break;
-                    const contLine = trimEndSlice(cursor.source, cursor.contentStart, cursor.lineEnd);
-                    const csep = findKeySep(contLine);
-                    if (csep === -1)
-                        break;
-                    const ckeyRaw = trimEndSlice(contLine, 0, csep);
-                    if (!isValidKey(ckeyRaw))
-                        break;
-                    const ckey = stripKeyQuotes(ckeyRaw, ctx.strict, continuationLine);
-                    if (!ckey)
-                        break;
-                    checkKeyLength(ckey, continuationLine);
-                    const valueUndecoded = trimSlice(contLine, csep + 2, contLine.length);
-                    let value = valueUndecoded;
-                    if (value !== '|' && value.includes('#'))
-                        value = stripComment(value);
-                    // contLine starts exactly at contentStart (no leading trim), so
-                    // the value's column is the indent plus its offset in contLine.
-                    const cValueCol = wantSource ? cursor.indent + csep + 2 + leadingWsLen(contLine.slice(csep + 2)) : 0;
-                    builder.setMapping(pendingItem, ckey, inlineOrBlockScalar(value, valueUndecoded === '|', ckeyIndent, continuationLine, cValueCol, valueUndecoded, cursor, ctx, builder));
-                }
-            }
-            else if (afterDash.endsWith(':') && isValidKey(trimSlice(afterDash, 0, afterDash.length - 1))) {
-                const key = stripKeyQuotes(trimSlice(afterDash, 0, afterDash.length - 1), ctx.strict, line);
-                checkKeyLength(key, line);
-                // §7.1 rule 3 / §7.2: sibling keys of an object item align at
-                // the column of the first key *after* `- `; a nested block
-                // must be indented deeper than that column, not merely deeper
-                // than the item's dash. A line at the key's own column is the
-                // next sibling key, so the bare key is `null`.
-                let keyColumn = cursor.contentStart + 1;
-                while (keyColumn < cursor.lineEnd && isTrimWhitespace(cursor.source.charCodeAt(keyColumn)))
-                    keyColumn++;
-                keyColumn -= cursor.lineStart;
-                cursor.next();
-                skipEmptyAndCommentLines(cursor);
-                const nested = blockOfBareKey(cursor, keyColumn, ctx, baseLine, builder);
-                pendingColumn = keyColumn;
-                pendingItem = builder.createMappingWith(key, nested ?? builder.null(line));
-            }
-            else {
-                // A quoted-or-typed scalar item — parseQuotedOrTyped enforces
-                // §10.1's unterminated / trailing-content strict checks.
-                items.push(parseQuotedOrTyped(afterDash, ctx, line, builder, dashSource));
-                cursor.next();
-            }
-        }
-        else {
-            const trimmed = cursorContent(cursor);
-            if (items !== null) {
-                if (ctx.strict)
-                    throw new LimaError({ code: 'INVALID_INDENTATION', line,
-                        message: `Lima: mixed map and array entries for the same key at line ${line}` });
-                cursor.next();
-                continue;
-            }
-            const bareKey = trimmed.charCodeAt(trimmed.length - 1) === 58;
-            const colonPos = bareKey && trimmed.indexOf(' ') === -1 ? -1 : findKeySep(trimmed);
-            const keyRaw = colonPos !== -1
-                ? trimEndSlice(trimmed, 0, colonPos)
-                : bareKey ? trimEndSlice(trimmed, 0, trimmed.length - 1) : '';
-            if ((keyRaw !== '' || colonPos !== -1) && !isValidKey(keyRaw)) {
-                // §5.1: not a usable key — an unrecognised line, skipped in non-strict mode and an error in strict
-                // mode, as at the top level (Core 1.1 §10.1)
-                if (ctx.strict)
-                    throw unrecognizedKeyLine(line, trimmed);
-                cursor.next();
-            }
-            else if (colonPos !== -1) {
-                if (entries === null)
-                    entries = builder.createMapping();
-                const key = stripKeyQuotes(keyRaw, ctx.strict, line);
-                checkKeyLength(key, line);
-                if (ctx.strict || ctx.onWarning !== undefined)
-                    checkDuplicateKey(builder.hasMappingKey(entries, key), key, line, ctx);
-                const rawUndecoded = trimSlice(trimmed, colonPos + 2, trimmed.length);
-                let raw = rawUndecoded;
-                if (raw !== '|' && raw.includes('#'))
-                    raw = stripComment(raw);
-                const valueCol = wantSource ? cursor.indent + colonPos + 2 + leadingWsLen(trimmed.slice(colonPos + 2)) : 0;
-                builder.setMapping(entries, key, inlineOrBlockScalar(raw, rawUndecoded === '|', baseIndent, line, valueCol, rawUndecoded, cursor, ctx, builder));
-            }
-            else if (bareKey) {
-                if (entries === null)
-                    entries = builder.createMapping();
-                const key = stripKeyQuotes(keyRaw, ctx.strict, line);
-                checkKeyLength(key, line);
-                if (ctx.strict || ctx.onWarning !== undefined)
-                    checkDuplicateKey(builder.hasMappingKey(entries, key), key, line, ctx);
-                cursor.next();
-                skipEmptyAndCommentLines(cursor);
-                const nested = blockOfBareKey(cursor, baseIndent, ctx, baseLine, builder);
-                builder.setMapping(entries, key, nested ?? builder.null(line));
-            }
-            else {
-                if (ctx.strict)
-                    throw new LimaError({ code: 'INVALID_INDENTATION', line,
-                        message: `Lima: indented freetext without a block scalar marker at line ${line}: "${trimmed}"` });
-                cursor.next();
-            }
         }
-    }
-    if (pendingItem !== null)
-        items.push(builder.mapping(pendingItem, baseLine + startLine));
-    return items !== null ? builder.array(items, baseLine + startLine) :
-        entries !== null ? builder.mapping(entries, baseLine + startLine) : null;
+        if (pendingItem !== null)
+            items.push(builder.mapping(pendingItem, baseLine + startLine));
+        return items !== null ? builder.array(items, baseLine + startLine) :
+            entries !== null ? builder.mapping(entries, baseLine + startLine) : null;
+    };
+    return parseCursorBlock;
+};
+const nativeBlockParser = blockParser(stripKeyQuotes, stripComment, parseFlowOrScalarValue, parseFlowSequence);
+/** Shared block grammar consuming one mutable physical-line cursor. */
+export const parseCursorBlock = (cursor, baseIndent, ctx, baseLine, builder, compact = false) => {
+    const positions = builder.sourcePositions;
+    const read = positions
+        ? blockParser(sourceKeyReader(cursor, positions), stripCommentKeepEscapes, flowValueReader(positions), sourceSequenceReader(positions))
+        : nativeBlockParser;
+    return read(cursor, baseIndent, ctx, baseLine, builder, compact);
 };
-export const parseBlockRange = (source, start, end, ctx, baseLine, builder, depthRisk) => {
-    const cursor = new BlockCursor(source, start, end);
+export const parseBlockRange = (source, start, end, ctx, baseLine, builder, depthRisk, cursor = new BlockCursor(source, start, end)) => {
     if (!cursor.next())
         return null;
     skipEmptyAndCommentLines(cursor);