@limaformat/lima 0.8.0 → 0.8.1

package/CHANGELOG.md

@@ -12,6 +12,15 @@ carry their own.
 
 ## [Unreleased]
 
+## [0.8.1] — 2026-11-06
+
+### Changed
+
+- `outline()` takes the positions of keys and comments from the parser's own readers as they read, instead of
+  matching the parsed tree to the lines afterwards. It grows linearly with its input (2,048 malformed lines in 15 ms
+  instead of 527); `parse` and `parseCore` keep their speed. For a few malformed inputs the result is now right where
+  the old matching took a key from another line.
+
 ## [0.8.0] — 2026-11-05
 
 ### Added

package/dist/block-cursor.d.ts

@@ -1,3 +1,4 @@
+import type { SourcePositions } from './builder.js';
 /**
  * Allocation-free physical-line cursor over one top-level block extent.
  * Positions are UTF-16 code-unit offsets. Indentation is the run of spaces
@@ -20,6 +21,20 @@ export declare class BlockCursor {
     private nextStart;
     constructor(source: string, rangeStart: number, rangeEnd: number);
     next(): boolean;
+    /** Consume the physical body of a block scalar, leaving the first dedented line. */
+    scalarLines(keyIndent: number): string[];
+    protected scalarBody(keyIndent: number): string[];
     get empty(): boolean;
     get firstCode(): number;
 }
+/** Reports comments only as lines are consumed, never inside a scalar body. */
+export declare class SourceBlockCursor extends BlockCursor {
+    private readonly positions;
+    private commentFrom;
+    private scalar;
+    constructor(source: string, start: number, end: number, positions: SourcePositions);
+    /** Exclude comment markers before this normalized UTF-16 offset on the current line. */
+    excludeCommentsBefore(offset: number): void;
+    next(): boolean;
+    protected scalarBody(keyIndent: number): string[];
+}

package/dist/block-cursor.js

@@ -1,4 +1,5 @@
 import { isTrimWhitespace } from './chars.js';
+import { commentStart } from './scalars.js';
 /**
  * Allocation-free physical-line cursor over one top-level block extent.
  * Positions are UTF-16 code-unit offsets. Indentation is the run of spaces
@@ -66,6 +67,21 @@ export class BlockCursor {
         this.nextStart = newline === -1 || newline >= this.rangeEnd ? this.rangeEnd : newline + 1;
         return true;
     }
+    /** Consume the physical body of a block scalar, leaving the first dedented line. */
+    scalarLines(keyIndent) {
+        this.next();
+        return this.scalarBody(keyIndent);
+    }
+    scalarBody(keyIndent) {
+        const lines = [];
+        while (this.valid) {
+            if (this.lineEnd - this.lineStart > this.asciiIndent && this.asciiIndent <= keyIndent)
+                break;
+            lines.push(this.source.slice(this.lineStart, this.lineEnd));
+            this.next();
+        }
+        return lines;
+    }
     get empty() {
         return this.contentStart === this.lineEnd;
     }
@@ -73,3 +89,33 @@ export class BlockCursor {
         return this.source.charCodeAt(this.contentStart);
     }
 }
+/** Reports comments only as lines are consumed, never inside a scalar body. */
+export class SourceBlockCursor extends BlockCursor {
+    positions;
+    commentFrom = 0;
+    scalar = false;
+    constructor(source, start, end, positions) {
+        super(source, start, end);
+        this.positions = positions;
+    }
+    /** Exclude comment markers before this normalized UTF-16 offset on the current line. */
+    excludeCommentsBefore(offset) {
+        this.commentFrom = offset;
+    }
+    next() {
+        if (this.valid && !this.scalar) {
+            const hash = commentStart(this.source.slice(this.commentFrom, this.lineEnd));
+            if (hash !== -1)
+                this.positions.comment(this.commentFrom + hash, this.lineEnd);
+        }
+        const valid = super.next();
+        this.commentFrom = this.contentStart;
+        return valid;
+    }
+    scalarBody(keyIndent) {
+        this.scalar = true;
+        const lines = super.scalarBody(keyIndent);
+        this.scalar = false;
+        return lines;
+    }
+}

package/dist/block.d.ts

@@ -9,13 +9,21 @@
  * never resolves a reference in the first place).
  */
 import { type ParseContext } from './normalize.js';
+import { parseFlowOrScalarValue } from './flow.js';
 import type { ValueBuilder } from './builder.js';
 import { BlockCursor } from './block-cursor.js';
+/**
+ * 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 declare const parseInlineValue: <V, M>(raw: string, marker: boolean, keyIndent: number, keyLine: number, valueCol: number, rawUndecoded: string, cursor: BlockCursor, ctx: ParseContext, builder: ValueBuilder<V, M>, readValue: typeof parseFlowOrScalarValue<V, M>) => V;
 export declare const findKeySep: (s: string) => number;
+declare const nativeBlockParser: <V, M>(cursor: BlockCursor, baseIndent: number, ctx: ParseContext, baseLine: number, builder: ValueBuilder<V, M>, compact?: boolean) => V | null;
 /** Shared block grammar consuming one mutable physical-line cursor. */
-export declare const parseCursorBlock: <V, M>(cursor: BlockCursor, baseIndent: number, ctx: ParseContext, baseLine: number, builder: ValueBuilder<V, M>, compact?: boolean) => V | null;
+export declare const parseCursorBlock: typeof nativeBlockParser;
 /** Complete block grammar over one UTF-16 source range. */
 export type BlockDepthRisk = {
     mayExceed: boolean;
 };
-export declare const parseBlockRange: <V, M>(source: string, start: number, end: number, ctx: ParseContext, baseLine: number, builder: ValueBuilder<V, M>, depthRisk: BlockDepthRisk) => V | null;
+export declare const parseBlockRange: <V, M>(source: string, start: number, end: number, ctx: ParseContext, baseLine: number, builder: ValueBuilder<V, M>, depthRisk: BlockDepthRisk, cursor?: BlockCursor) => V | null;
+export {};