@limaformat/lima 0.8.0 → 0.8.1

package/dist/builder.d.ts

@@ -25,7 +25,25 @@
  * therefore performance — is identical either way, verified by benchmark.
  */
 import type { ReferenceSource } from './reference-tokens2.js';
+/**
+ * Reader events for structural editor output. All positions are UTF-16 offsets
+ * in the normalized source; ends are exclusive, separator is the colon and
+ * line is one-based. A zero-width key denotes a tolerant entry without a
+ * physical separator; its value's events are still balanced but not emitted.
+ * Readers select reporting functions once on entry. Native/References builders
+ * never set this hook, so their key loops do no optional-sink checks.
+ */
+export interface SourcePositions {
+    key(key: string, start: number, end: number, separator: number, line: number): void;
+    comment(start: number, end: number): void;
+    /**
+     * On failure, discard key events left unfinished by `read`. Return `fallback`
+     * for non-resource LimaErrors; rethrow resource-limit and non-Lima errors.
+     */
+    recover<T>(read: () => T, fallback: T): T;
+}
 export interface ValueBuilder<V, M = Map<string, V>> {
+    readonly sourcePositions?: SourcePositions;
     /** Whether scalar builders need physical source anchors for editor positions. */
     readonly positions?: boolean;
     null(line: number): V;

package/dist/flow.d.ts

@@ -1,6 +1,6 @@
 /** Core §15.8 flow collections: `[...]` sequences and `{...}` mappings. */
 import { type ParseContext } from './normalize.js';
-import type { ValueBuilder } from './builder.js';
+import type { SourcePositions, ValueBuilder } from './builder.js';
 import type { ReferenceSource } from './reference-tokens2.js';
 /** Stateful comma-item cursor over a flow container's original string. */
 export declare class FlowCursor {
@@ -14,13 +14,15 @@ export declare class FlowCursor {
     next(): boolean;
     get isLast(): boolean;
 }
-export declare const parseFlowSequence: <V, M>(val: string, ctx: ParseContext, line: number, builder: ValueBuilder<V, M>, source?: ReferenceSource) => V[] | null;
+export declare const parseFlowSequence: <V, M>(val: string, ctx: ParseContext, line: number, builder: ValueBuilder<V, M>, source?: ReferenceSource, offset?: number) => V[] | null;
 /**
  * Index of the key/value `: ` separator within a flow-mapping item — the
  * first `: ` that is not inside a quoted key (§5.1). Returns -1 when the
  * item has no separator.
  */
 export declare const flowItemSeparator: (val: string, start: number, end: number) => number;
-export declare const parseFlowMapping: <V, M>(val: string, ctx: ParseContext, line: number, builder: ValueBuilder<V, M>, source?: ReferenceSource) => V | null;
+export declare const parseFlowMapping: <V, M>(val: string, ctx: ParseContext, line: number, builder: ValueBuilder<V, M>, source?: ReferenceSource, offset?: number) => V | null;
 /** Parses a value that may be a flow collection, without probing both flow parsers for ordinary scalars. */
-export declare const parseFlowOrScalarValue: <V, M>(raw: string, ctx: ParseContext, line: number, builder: ValueBuilder<V, M>, source?: ReferenceSource) => V;
+export declare const parseFlowOrScalarValue: <V, M>(raw: string, ctx: ParseContext, line: number, builder: ValueBuilder<V, M>, source?: ReferenceSource, offset?: number) => V;
+/** Select recovery once, outside the block reader's key loop. */
+export declare const flowValueReader: (positions?: SourcePositions) => typeof parseFlowOrScalarValue;

package/dist/flow.js

@@ -118,7 +118,7 @@ export class FlowCursor {
 }
 const isNestedFlowConstruct = (item) => (item.charCodeAt(0) === 91 && item.charCodeAt(item.length - 1) === 93) ||
     (item.charCodeAt(0) === 123 && item.charCodeAt(item.length - 1) === 125);
-export const parseFlowSequence = (val, ctx, line, builder, source) => {
+export const parseFlowSequence = (val, ctx, line, builder, source, offset = 0) => {
     if (val.charCodeAt(0) !== 91 || val.charCodeAt(val.length - 1) !== 93)
         return null;
     const innerStart = trimStart(val, 1, val.length - 1);
@@ -147,7 +147,7 @@ export const parseFlowSequence = (val, ctx, line, builder, source) => {
             });
         }
         if (item.charCodeAt(0) === 123 && item.charCodeAt(item.length - 1) === 125) {
-            const nested = parseFlowMapping(item, ctx, line, builder, elementSource(source, val, start, end));
+            const nested = parseFlowMapping(item, ctx, line, builder, elementSource(source, val, start, end), offset + start);
             if (nested !== null) {
                 items.push(nested);
                 continue;
@@ -174,11 +174,18 @@ export const flowItemSeparator = (val, start, end) => {
     const sep = val.indexOf(': ', scan);
     return sep === -1 || sep >= end ? -1 : sep;
 };
-export const parseFlowMapping = (val, ctx, line, builder, source) => {
+const sourceKeyReader = (positions, offset) => (raw, strict, line, start, colon) => {
+    const key = stripKeyQuotes(raw, strict, line);
+    positions.key(key, offset + start, offset + start + raw.length, offset + colon, line);
+    return key;
+};
+export const parseFlowMapping = (val, ctx, line, builder, source, offset = 0) => {
     if (val.charCodeAt(0) !== 123 || val.charCodeAt(val.length - 1) !== 125)
         return null;
     const innerStart = trimStart(val, 1, val.length - 1);
     const innerEnd = trimEnd(val, innerStart, val.length - 1);
+    const positions = builder.sourcePositions;
+    const readKey = positions ? sourceKeyReader(positions, offset) : stripKeyQuotes;
     const entries = builder.createMapping();
     if (innerStart === innerEnd)
         return builder.mapping(entries, line);
@@ -209,7 +216,7 @@ export const parseFlowMapping = (val, ctx, line, builder, source) => {
             // list is closed and does not cover this — same as the top level).
             continue;
         }
-        const key = stripKeyQuotes(keyRaw, ctx.strict, line);
+        const key = readKey(keyRaw, ctx.strict, line, keyStart, colonPos);
         checkKeyLength(key, line);
         if (ctx.strict || ctx.onWarning !== undefined) {
             checkDuplicateKey(builder.hasMappingKey(entries, key), key, line, ctx);
@@ -225,19 +232,24 @@ export const parseFlowMapping = (val, ctx, line, builder, source) => {
     return builder.mapping(entries, line);
 };
 /** Parses a value that may be a flow collection, without probing both flow parsers for ordinary scalars. */
-export const parseFlowOrScalarValue = (raw, ctx, line, builder, source) => {
+export const parseFlowOrScalarValue = (raw, ctx, line, builder, source, offset = 0) => {
     const first = raw.charCodeAt(0);
     if (first === 91) {
-        const sequence = parseFlowSequence(raw, ctx, line, builder, source);
+        const sequence = parseFlowSequence(raw, ctx, line, builder, source, offset);
         if (sequence !== null)
             return builder.array(sequence, line);
         return parseScalarValue(raw, ctx, line, builder, source);
     }
     else if (first === 123) {
-        const mapping = parseFlowMapping(raw, ctx, line, builder, source);
+        const mapping = parseFlowMapping(raw, ctx, line, builder, source, offset);
         if (mapping !== null)
             return mapping;
         return parseScalarValue(raw, ctx, line, builder, source);
     }
     return parseQuotedOrTyped(raw, ctx, line, builder, source);
 };
+/** Select recovery once, outside the block reader's key loop. */
+export const flowValueReader = (positions) => positions ? sourceValueReader(positions) : parseFlowOrScalarValue;
+// Structural values are still physical text; reference anchors would rescan
+// every flow prefix for codepoint columns that the outline never uses.
+const sourceValueReader = (positions) => (raw, ctx, line, builder, _source, offset) => positions.recover(() => parseFlowOrScalarValue(raw, ctx, line, builder, undefined, offset), builder.null(line));

package/dist/outline.js

@@ -1,136 +1,173 @@
-import { BlockCursor } from './block-cursor.js';
-import { findKeySep, parseCursorBlock } from './block.js';
-import { buildBlockScalar } from './block-scalar.js';
+import { SourceBlockCursor } from './block-cursor.js';
+import { parseBlockRange, parseInlineValue } from './block.js';
 import { parseCore } from './core.js';
 import { LimaError } from './errors.js';
-import { FlowCursor, flowItemSeparator, parseFlowOrScalarValue } from './flow.js';
-import { byteLength, DOCUMENT_SIZE_LIMIT, TOP_LEVEL_KEY_LIMIT, NESTING_DEPTH_LIMIT, checkKeyLength, checkDuplicateKey, } from './normalize.js';
+import { flowValueReader } from './flow.js';
+import { NESTING_DEPTH_LIMIT, checkKeyLength, checkDuplicateKey, } from './normalize.js';
 import { parse } from './references2.js';
 import { scanKeys } from './scanner.js';
-import { isValidKey, stripComment, stripCommentKeepEscapes, stripKeyQuotes } from './scalars.js';
+import { stripCommentKeepEscapes, stripKeyQuotes } from './scalars.js';
+import { isBlockScalarMarker } from './structure.js';
 /** Core §3 normalization, with a boundary map back to the BOM-free physical input. */
 function normalize(input) {
-    let source = '';
+    const units = [];
     const offsets = [];
     let leading = true;
     for (let i = 0; i < input.length; i++) {
         const c = input[i];
         if (c === '\r' || c === '\n') {
-            while (source.endsWith(' ')) {
-                source = source.slice(0, -1);
+            while (units.at(-1) === ' ') {
+                units.pop();
                 offsets.pop();
             }
             offsets.push(i);
-            source += '\n';
+            units.push('\n');
             if (c === '\r' && input[i + 1] === '\n')
                 i++;
             leading = true;
         }
         else if (leading && c === '\t') {
-            source += '  ';
+            units.push(' ', ' ');
             offsets.push(i, i);
         }
         else {
-            source += c;
+            units.push(c);
             offsets.push(i);
             if (c !== ' ')
                 leading = false;
         }
     }
-    while (source.endsWith(' ')) {
-        source = source.slice(0, -1);
+    while (units.at(-1) === ' ') {
+        units.pop();
         offsets.pop();
     }
     offsets.push(input.length);
-    return { source, offsets };
+    return { source: units.join(''), offsets };
 }
 /** Editor positions count UTF-16 units, including CRLF's two units. */
 function spanReader(input, offsets) {
     const lines = [0];
+    const lineNumbers = new Uint32Array(input.length + 1);
+    let line = 0;
     for (let i = 0; i < input.length; i++) {
+        lineNumbers[i] = line;
         if (input[i] === '\r') {
             if (input[i + 1] === '\n')
-                i++;
+                lineNumbers[++i] = line;
             lines.push(i + 1);
+            line++;
         }
-        else if (input[i] === '\n')
+        else if (input[i] === '\n') {
             lines.push(i + 1);
-    }
-    const point = (position) => {
-        const offset = position;
-        let low = 0, high = lines.length;
-        while (low + 1 < high) {
-            const middle = (low + high) >>> 1;
-            if (lines[middle] <= offset)
-                low = middle;
-            else
-                high = middle;
+            line++;
         }
-        return { line: low + 1, column: offset - lines[low] + 1, offset };
+    }
+    lineNumbers[input.length] = line;
+    const point = (offset) => {
+        const line = lineNumbers[offset];
+        return { line: line + 1, column: offset - lines[line] + 1, offset };
     };
     return (start, end) => ({ start: point(offsets[start]),
         end: point(end > start ? offsets[end - 1] + 1 : offsets[end]) });
 }
-/** Physical flow sites use the parser's item and separator readers. */
-function flowSites(source, start, end, line, sites) {
-    const value = source.slice(start, end).trimEnd();
-    const first = value[0], last = value.at(-1);
-    if (!((first === '{' && last === '}') || (first === '[' && last === ']')))
-        return;
-    const cursor = new FlowCursor(value, 1, value.length - 1);
-    while (cursor.next()) {
-        const a = cursor.itemStart, b = cursor.itemEnd;
-        if (first === '[') {
-            if (value[a] === '{')
-                flowSites(source, start + a, start + b, line, sites);
-            continue;
-        }
-        const colon = flowItemSeparator(value, a, b);
-        if (colon === -1)
-            continue;
-        const raw = value.slice(a, colon).trimEnd();
-        if (isValidKey(raw))
-            sites.push({ key: stripKeyQuotes(raw), start: start + a,
-                end: start + a + raw.length, colon: start + colon, line, sequence: false });
-    }
-}
-/**
- * The real block/flow parsers build an occurrence tree. With warnings enabled,
- * hasMappingKey records a key's line before its value is read. Sequence-item
- * entries without duplicate checks are anchored by their value's first line.
- * Physical sites are assigned in source order when walking the finished tree,
- * so a flow key named like its enclosing key cannot steal the parent's site.
- */
-function outlineBuilder(currentLine) {
-    const leaf = (line) => ({ line });
+/** Pair each reader event with the value built immediately after it. */
+function outlineBuilder(comment) {
+    const pending = [];
+    const failed = new WeakSet();
+    const leaf = () => ({});
+    const entry = (value) => {
+        const position = pending.pop();
+        if (!position)
+            throw new Error('Lima: missing outline key position');
+        return { position, value };
+    };
     return {
-        null: leaf, bool: (_, line) => leaf(line), int: (_, line) => leaf(line),
-        float: (_, line) => leaf(line), string: (_, line) => leaf(line), instant: (_, line) => leaf(line),
-        array: (items, line) => ({ line, items }), createMapping: () => [],
-        createMappingWith: (key, value) => [{ key, line: value.line, exact: false, sequence: true, value }],
-        hasMappingKey: (entries, key) => {
-            entries.push({ key, line: currentLine(), exact: true, sequence: false });
-            return false; // diagnostics come from separate public-parser passes
+        positions: true,
+        sourcePositions: {
+            key: (key, start, end, separator, line) => pending.push({ key, start, end, separator, line, duplicates: false }),
+            comment,
+            recover: (read, fallback) => {
+                const depth = pending.length;
+                try {
+                    const value = read();
+                    if (pending.length !== depth)
+                        throw new Error('Lima: unbalanced outline key positions');
+                    return value;
+                }
+                catch (error) {
+                    pending.length = depth;
+                    if (!(error instanceof LimaError) || error.code === 'RESOURCE_LIMIT')
+                        throw error;
+                    if (fallback !== null && typeof fallback === 'object')
+                        failed.add(fallback);
+                    return fallback;
+                }
+            },
         },
-        setMapping: (entries, key, value) => {
-            const entry = entries.findLast((e) => e.key === key && e.value === undefined);
-            if (entry)
-                entry.value = value;
-            else
-                entries.push({ key, line: value.line, exact: false, sequence: false, value });
+        null: leaf, bool: leaf, int: leaf, float: leaf, string: leaf, instant: leaf,
+        // A failed mapping value keeps its key; an unreadable whole item is skipped.
+        array: (items) => ({ items: items.filter((item) => !failed.has(item)) }), createMapping: () => [],
+        createMappingWith: (_, value) => [entry(value)],
+        hasMappingKey: () => {
+            const position = pending.at(-1);
+            if (!position)
+                throw new Error('Lima: missing outline duplicate position');
+            position.duplicates = true;
+            return false; // diagnostics are collected in source order below
         },
-        mappingMaxDepth: () => 0, mapping: (entries, line) => ({ line, entries }),
+        setMapping: (entries, _, value) => { entries.push(entry(value)); },
+        mappingMaxDepth: () => 0, mapping: (entries) => ({ entries }),
     };
 }
+/** Consume scanner ranges once; nested grammar stays in the block and flow readers. */
+function readOutline(source, builder, ctx, emit, walk) {
+    const positions = builder.sourcePositions;
+    if (!positions)
+        throw new Error('Lima: missing outline source positions');
+    const readValue = flowValueReader(positions);
+    const matches = scanKeys(source);
+    const preamble = new SourceBlockCursor(source, 0, matches[0]?.matchStart ?? source.length, positions);
+    while (preamble.next()) { }
+    const topKeys = new Set();
+    for (let i = 0; i < matches.length; i++) {
+        const match = matches[i];
+        const end = matches[i + 1]?.matchStart ?? source.length;
+        const key = match.unquoted ?? match.singleQuoted ?? stripKeyQuotes(source.slice(match.matchStart, match.sepStart - 1));
+        checkDuplicateKey(topKeys.has(key), key, match.line, ctx);
+        topKeys.add(key);
+        emit({ key, start: match.matchStart, end: match.sepStart - 1,
+            separator: match.sepStart - 1, line: match.line, duplicates: true }, []);
+        const cursor = new SourceBlockCursor(source, match.isBlock ? match.rawStart : match.matchStart, end, positions);
+        if (match.isBlock) {
+            const value = parseBlockRange(source, match.rawStart, end, ctx, match.line + 1, builder, { mayExceed: false }, cursor);
+            if (value)
+                walk(value, [key]);
+        }
+        else {
+            cursor.next();
+            cursor.excludeCommentsBefore(match.rawStart);
+            const raw = source.slice(match.rawStart, cursor.lineEnd);
+            const value = stripCommentKeepEscapes(raw).trim();
+            const column = match.rawStart - match.matchStart + raw.length - raw.trimStart().length;
+            walk(parseInlineValue(value, isBlockScalarMarker(source, match.rawStart, cursor.lineEnd), 0, match.line, column, raw, cursor, ctx, builder, readValue), [key]);
+        }
+        while (cursor.valid)
+            cursor.next();
+    }
+}
 /** Source structure for editors; references are only evaluated by the diagnostic oracle. */
 export function outline(frontMatter) {
     const diagnostics = [];
     const keys = [];
     const comments = [];
     const result = { offsetUnit: 'utf16-code-unit', keys, comments, diagnostics };
+    const diagnosticKeys = new Set();
     const addWarning = (warning) => {
-        if (!diagnostics.some((d) => d.code === warning.code && d.line === warning.line && d.key === warning.key))
-            diagnostics.push(warning);
+        const identity = JSON.stringify([warning.code, warning.line, warning.key]);
+        if (diagnosticKeys.has(identity))
+            return;
+        diagnosticKeys.add(identity);
+        diagnostics.push(warning);
     };
     let limited = false;
     try {
@@ -139,7 +176,7 @@ export function outline(frontMatter) {
     catch (error) {
         if (!(error instanceof LimaError))
             throw error;
-        diagnostics.push({ ...error, message: error.message });
+        addWarning({ ...error, message: error.message });
         limited = error.code === 'RESOURCE_LIMIT';
     }
     // Also check limits beyond strict mode's first error, and collect duplicate
@@ -153,179 +190,51 @@ export function outline(frontMatter) {
         if (error.code === 'RESOURCE_LIMIT') {
             limited = true;
             if (!diagnostics.some((d) => d.code === error.code && d.line === error.line))
-                diagnostics.push({ ...error, message: error.message });
+                addWarning({ ...error, message: error.message });
         }
     }
     if (limited)
         return result;
     try {
-        if (byteLength(frontMatter) > DOCUMENT_SIZE_LIMIT)
-            throw new LimaError({ code: 'RESOURCE_LIMIT', line: 1,
-                message: `Lima: document exceeds maximum size of ${DOCUMENT_SIZE_LIMIT} bytes at line 1` });
         const input = frontMatter.startsWith('\uFEFF') ? frontMatter.slice(1) : frontMatter;
         const { source, offsets } = normalize(input);
         const span = spanReader(input, offsets);
-        const matches = scanKeys(source);
-        if (matches.length > TOP_LEVEL_KEY_LIMIT)
-            throw new LimaError({ code: 'RESOURCE_LIMIT', line: 1,
-                message: `Lima: too many top-level key entries (max ${TOP_LEVEL_KEY_LIMIT}) at line 1` });
-        const scalarLines = new Set();
         const ctx = { strict: false, onWarning: (warning) => addWarning(warning) };
-        const topKeys = new Set();
-        const emit = (site, path) => {
-            checkKeyLength(site.key, site.line);
-            const colon = span(site.colon, site.colon + 1);
+        const builder = outlineBuilder((start, end) => {
+            const comment = span(start, end);
+            let physicalEnd = comment.end.offset;
+            while (physicalEnd < input.length && input[physicalEnd] !== '\r' && input[physicalEnd] !== '\n')
+                physicalEnd++;
+            comments.push({ start: comment.start, end: { ...comment.end,
+                    column: comment.end.column + physicalEnd - comment.end.offset, offset: physicalEnd } });
+        });
+        const emit = (position, path) => {
+            checkKeyLength(position.key, position.line);
+            const colon = span(position.separator, position.separator + 1);
             const separator = input[colon.end.offset] === ' '
                 ? { start: colon.start, end: { ...colon.end, column: colon.end.column + 1, offset: colon.end.offset + 1 } }
                 : colon;
-            keys.push({ key: site.key, path: [...path, site.key], span: span(site.start, site.end), separator });
-            const lineEnd = source.indexOf('\n', site.colon);
-            const end = lineEnd === -1 ? source.length : lineEnd;
-            if (source.slice(site.colon + 1, end).trim() === '|') {
-                const body = source.slice(end + 1).split('\n');
-                if (body.at(-1) === '')
-                    body.pop();
-                const column = site.start - (source.lastIndexOf('\n', site.start - 1) + 1);
-                const consumed = buildBlockScalar(body, column, site.line, ctx, outlineBuilder(() => site.line)).consumed;
-                for (let j = 1; j <= consumed; j++)
-                    scalarLines.add(site.line + j);
-            }
+            keys.push({ key: position.key, path: [...path, position.key], span: span(position.start, position.end), separator });
         };
-        const walk = (value, path, sites, position, depth = 0) => {
+        const walk = (value, path, depth = 0) => {
             if (value.entries || value.items)
                 depth++;
             if (depth > NESTING_DEPTH_LIMIT)
                 throw new LimaError({ code: 'RESOURCE_LIMIT', line: 1,
                     message: `Lima: nesting depth exceeds maximum of ${NESTING_DEPTH_LIMIT} at line 1` });
-            let keyColumn;
             const seen = new Set();
-            for (const entry of value.entries ?? []) {
-                const site = sites.find((s) => s.key === entry.key && s.start > position.after &&
-                    !scalarLines.has(s.line) && s.sequence === entry.sequence &&
-                    (entry.exact ? s.line === entry.line : s.line <= entry.line) &&
-                    (entry.exact || entry.sequence || keyColumn === undefined ||
-                        s.start - (source.lastIndexOf('\n', s.start - 1) + 1) === keyColumn));
-                // Incomplete content can produce a tree entry without a readable
-                // physical key. Omit that entry and its children, then keep walking.
-                if (!site)
+            for (const { position, value: child } of value.entries ?? []) {
+                if (position.start === position.end)
                     continue;
-                keyColumn ??= site.start - (source.lastIndexOf('\n', site.start - 1) + 1);
-                if (entry.exact)
-                    checkDuplicateKey(seen.has(entry.key), entry.key, site.line, ctx);
-                seen.add(entry.key);
-                emit(site, path);
-                position.after = site.start;
-                if (entry.value)
-                    walk(entry.value, [...path, entry.key], sites, position, depth);
+                if (position.duplicates)
+                    checkDuplicateKey(seen.has(position.key), position.key, position.line, ctx);
+                seen.add(position.key);
+                emit(position, path);
+                walk(child, [...path, position.key], depth);
             }
-            value.items?.forEach((item, index) => walk(item, [...path, String(index)], sites, position, depth));
+            value.items?.forEach((item, index) => walk(item, [...path, String(index)], depth));
         };
-        for (let i = 0; i < matches.length; i++) {
-            const match = matches[i];
-            const end = matches[i + 1]?.matchStart ?? source.length;
-            const key = match.unquoted ?? match.singleQuoted ?? stripKeyQuotes(source.slice(match.matchStart, match.sepStart - 1));
-            const site = { key, start: match.matchStart, end: match.sepStart - 1,
-                colon: match.sepStart - 1, line: match.line, sequence: false };
-            checkDuplicateKey(topKeys.has(key), key, site.line, ctx);
-            topKeys.add(key);
-            emit(site, []);
-            const sites = [];
-            const cursor = new BlockCursor(source, match.isBlock ? match.rawStart : match.matchStart, end);
-            while (cursor.next()) {
-                const line = (match.isBlock ? match.line + 1 : match.line) + cursor.lineIndex;
-                if (scalarLines.has(line) || cursor.empty || cursor.firstCode === 35)
-                    continue;
-                let start = cursor.contentStart;
-                let sequence = false;
-                if (source[start] === '-' && (start + 1 === cursor.lineEnd || source[start + 1].trim() === '')) {
-                    sequence = true;
-                    start++;
-                    while (start < cursor.lineEnd && source[start].trim() === '')
-                        start++;
-                }
-                const content = source.slice(start, cursor.lineEnd).trimEnd();
-                let colon = findKeySep(content);
-                if (colon === -1 && content.endsWith(':'))
-                    colon = content.length - 1;
-                const rawKey = colon === -1 ? '' : content.slice(0, colon).trimEnd();
-                let valueStart = start;
-                if (colon !== -1 && isValidKey(rawKey)) {
-                    const candidate = { key: stripKeyQuotes(rawKey), start, end: start + rawKey.length,
-                        colon: start + colon, line, sequence };
-                    if (start !== match.matchStart)
-                        sites.push(candidate);
-                    valueStart = start + colon + 1;
-                    while (valueStart < cursor.lineEnd && source[valueStart].trim() === '')
-                        valueStart++;
-                }
-                const raw = stripCommentKeepEscapes(source.slice(valueStart, cursor.lineEnd));
-                flowSites(source, valueStart, valueStart + raw.length, line, sites);
-            }
-            if (match.isBlock) {
-                // Some malformed flows throw even in non-strict mode. Replace
-                // their value with a scalar (or skip an unreadable item) and retry.
-                let tolerant = source;
-                for (;;) {
-                    const block = new BlockCursor(tolerant, match.rawStart, end);
-                    while (block.next() && (block.empty || block.firstCode === 35)) { }
-                    if (!block.valid || (block.asciiIndent === 0 && block.firstCode !== 45))
-                        break;
-                    const builder = outlineBuilder(() => match.line + 1 + block.lineIndex);
-                    try {
-                        const value = parseCursorBlock(block, block.asciiIndent, ctx, match.line + 1, builder, block.asciiIndent === 0);
-                        if (value)
-                            walk(value, [key], sites, { after: site.start });
-                        break;
-                    }
-                    catch (error) {
-                        if (!(error instanceof LimaError))
-                            throw error;
-                        if (error.code === 'RESOURCE_LIMIT')
-                            throw error;
-                        const line = match.line + 1 + block.lineIndex;
-                        const keySite = sites.find((s) => s.line === line && (s.start === block.contentStart || s.sequence));
-                        const a = keySite ? keySite.colon + 1 : block.lineStart, b = block.lineEnd;
-                        const replacement = keySite ? ' 0'.padEnd(b - a, ' ') : ' '.repeat(b - a);
-                        tolerant = tolerant.slice(0, a) + replacement + tolerant.slice(b);
-                    }
-                }
-            }
-            else {
-                const raw = stripComment(source.slice(match.rawStart, match.inlineEnd ?? end)).trim();
-                if (raw !== '|') {
-                    try {
-                        walk(parseFlowOrScalarValue(raw, ctx, match.line, outlineBuilder(() => match.line)), [key], sites, { after: site.start });
-                    }
-                    catch (error) {
-                        if (!(error instanceof LimaError) || error.code === 'RESOURCE_LIMIT')
-                            throw error;
-                    }
-                }
-            }
-        }
-        const lines = new BlockCursor(source, 0, source.length);
-        while (lines.next()) {
-            if (scalarLines.has(lines.lineIndex + 1))
-                continue;
-            let start = lines.contentStart;
-            // Quoted-key contents do not participate in value comment stripping.
-            const key = keys.find((k) => k.span.start.line === lines.lineIndex + 1);
-            if (key)
-                while (start < lines.lineEnd && offsets[start] < key.separator.end.offset)
-                    start++;
-            const raw = source.slice(start, lines.lineEnd);
-            const kept = stripCommentKeepEscapes(raw);
-            if (kept.length !== raw.length) {
-                const hash = source.indexOf('#', start + kept.length);
-                const comment = span(hash, lines.lineEnd);
-                let end = comment.end.offset;
-                while (end < input.length && input[end] !== '\r' && input[end] !== '\n')
-                    end++;
-                comments.push({ start: comment.start, end: { ...comment.end,
-                        column: comment.end.column + end - comment.end.offset, offset: end } });
-            }
-        }
-        keys.sort((a, b) => a.span.start.offset - b.span.start.offset);
+        readOutline(source, builder, ctx, emit, walk);
     }
     catch (error) {
         if (!(error instanceof LimaError))
@@ -333,7 +242,7 @@ export function outline(frontMatter) {
         keys.length = 0;
         comments.length = 0;
         if (!diagnostics.some((d) => d.code === error.code && d.line === error.line))
-            diagnostics.push({ ...error, message: error.message });
+            addWarning({ ...error, message: error.message });
     }
     return result;
 }

package/dist/scalars.d.ts

@@ -120,6 +120,8 @@ export declare const closingQuoteIndex: (s: string, singleQuoteEscape?: boolean)
  */
 export declare const isValidKey: (raw: string) => boolean;
 export declare const unescapeDQ: (s: string, strict?: boolean, line?: number) => string;
+/** UTF-16 offset of the first unescaped, unquoted hash, or -1. */
+export declare const commentStart: (val: string) => number;
 /**
  * The value text with a trailing `#` comment removed, but with `\#`
  * escapes left as written. This is the *physical* form a References 2.0