@idfkit/core 0.2.0-rc.1 → 0.2.0

package/dist/parse/lexer.d.ts

@@ -6,11 +6,47 @@ export interface RawObject {
     values: string[];
     /** 1-based line where the object starts, for diagnostics. */
     line: number;
+    /** 1-based column where the object starts, for diagnostics. */
+    column?: number;
+    /**
+     * Absolute offset of the object's first character in the source text.
+     *
+     * One number per object, so that a finding about a FIELD can be positioned without the lexer
+     * recording a line for every field of every object. The rescan that uses it runs only when a
+     * finding is being built.
+     */
+    offset?: number;
 }
 export interface LexDiagnostic {
     message: string;
     line: number;
+    /**
+     * Machine-readable kind, from the vocabulary both libraries share.
+     *
+     * Derived from Python's exception hierarchy by dropping the `Error` suffix, so neither language
+     * invented it and the mapping stays mechanical. The conformance corpus compares a finding on
+     * `(code, line, typeName)` and never on `message`: wording is a presentation choice each library
+     * should stay free to improve, and pinning it would turn every improvement into a failure.
+     */
+    code?: ParseDiagnosticCode;
+    /** 1-based column, when the lexer knew one. */
+    column?: number;
+    /** Path the text came from, when it came from a file rather than a string. */
+    filepath?: string;
+    /**
+     * Object type the problem occurred in, when known.
+     *
+     * Declared here rather than only on `ParseDiagnostic` because the lexer knows it too: an
+     * unterminated object has read its type name before it runs out of input, and a finding that
+     * drops it says only that something went wrong somewhere.
+     */
+    typeName?: string;
 }
+/**
+ * The shared diagnostic vocabulary. The table lives in
+ * `idfkit-conformance/runners/compare.md`; a code outside it is a difference, not a near match.
+ */
+export type ParseDiagnosticCode = 'UnknownObjectType' | 'InvalidField' | 'Range' | 'DuplicateObject' | 'ParseError' | 'VersionMismatch' | 'UnsupportedVersion' | 'SchemaNotFound';
 export interface LexOptions {
     /** Report a problem instead of throwing. */
     onDiagnostic?: (diagnostic: LexDiagnostic) => void;
@@ -18,20 +54,13 @@ export interface LexOptions {
 /**
  * Split IDF text into raw objects.
  *
- * A hand-written character scan rather than a regex. The Python library matches
- * objects with a `(?:[^;!]*(?:![^\n]*\n)?)*?` inner loop; that is a nested
- * quantifier, so it backtracks badly on malformed input and cannot report where
- * the problem was. A scanner is about the same amount of code, is linear in the
- * input, and always knows its line number.
- *
- * The grammar is small:
- *   - `!` starts a comment running to end of line
- *   - `,` separates fields
- *   - `;` terminates an object
- *   - everything else is field text, trimmed
+ * The character rules are not here: they live in `scan.ts`, which the syntax layer reads through
+ * as well. Two copies of "step over a comment between a separator and its value" that differ by
+ * one character put a finding on the wrong field, so there is one copy (research R3).
  *
- * There are no string literals and no escape sequences, so a comma cannot occur
- * inside a field value. Real files depend on that.
+ * This function is what remains once those rules are elsewhere: assembling values from the text
+ * runs the scan reports, and turning a statement into a `RawObject` or into a diagnostic. It asks
+ * for no comment and no region, so it pays for neither, and it builds no syntax layer.
  */
 export declare function lex(text: string, options?: LexOptions): RawObject[];
 //# sourceMappingURL=lexer.d.ts.map

package/dist/parse/lexer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lexer.d.ts","sourceRoot":"","sources":["../../src/parse/lexer.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,MAAM,WAAW,SAAS;IACxB,qEAAqE;IACrE,QAAQ,EAAE,MAAM,CAAC;IACjB,8EAA8E;IAC9E,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,UAAU;IACzB,4CAA4C;IAC5C,YAAY,CAAC,EAAE,CAAC,UAAU,EAAE,aAAa,KAAK,IAAI,CAAC;CACpD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,UAAe,GAAG,SAAS,EAAE,CAkGvE"}
+{"version":3,"file":"lexer.d.ts","sourceRoot":"","sources":["../../src/parse/lexer.ts"],"names":[],"mappings":"AAEA,4EAA4E;AAC5E,MAAM,WAAW,SAAS;IACxB,qEAAqE;IACrE,QAAQ,EAAE,MAAM,CAAC;IACjB,8EAA8E;IAC9E,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAC;IACb,+DAA+D;IAC/D,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,mBAAmB,CAAC;IAC3B,+CAA+C;IAC/C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAC3B,mBAAmB,GACnB,cAAc,GACd,OAAO,GACP,iBAAiB,GACjB,YAAY,GACZ,iBAAiB,GACjB,oBAAoB,GACpB,gBAAgB,CAAC;AAErB,MAAM,WAAW,UAAU;IACzB,4CAA4C;IAC5C,YAAY,CAAC,EAAE,CAAC,UAAU,EAAE,aAAa,KAAK,IAAI,CAAC;CACpD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,UAAe,GAAG,SAAS,EAAE,CAgFvE"}

package/dist/parse/lexer.js

@@ -1,105 +1,87 @@
+import { scan } from './scan.js';
 /**
  * Split IDF text into raw objects.
  *
- * A hand-written character scan rather than a regex. The Python library matches
- * objects with a `(?:[^;!]*(?:![^\n]*\n)?)*?` inner loop; that is a nested
- * quantifier, so it backtracks badly on malformed input and cannot report where
- * the problem was. A scanner is about the same amount of code, is linear in the
- * input, and always knows its line number.
+ * The character rules are not here: they live in `scan.ts`, which the syntax layer reads through
+ * as well. Two copies of "step over a comment between a separator and its value" that differ by
+ * one character put a finding on the wrong field, so there is one copy (research R3).
  *
- * The grammar is small:
- *   - `!` starts a comment running to end of line
- *   - `,` separates fields
- *   - `;` terminates an object
- *   - everything else is field text, trimmed
- *
- * There are no string literals and no escape sequences, so a comma cannot occur
- * inside a field value. Real files depend on that.
+ * This function is what remains once those rules are elsewhere: assembling values from the text
+ * runs the scan reports, and turning a statement into a `RawObject` or into a diagnostic. It asks
+ * for no comment and no region, so it pays for neither, and it builds no syntax layer.
  */
 export function lex(text, options = {}) {
     const objects = [];
     const report = options.onDiagnostic;
-    const length = text.length;
-    /** Field text pieces, split whenever a comment interrupts a field. */
+    /** Field text pieces, one per run the scan reports, joined when the field closes. */
     let chunks = [];
     /** Fields of the object being read; index 0 ends up being the type name. */
     let values = [];
-    let index = 0;
-    let line = 1;
-    let fieldStart = 0;
+    /**
+     * Where the current statement starts.
+     *
+     * The first NON-BLANK character, not the start of the field text: Python's regex matches the
+     * type name itself, so an object indented three spaces reports column 4 there and has to report
+     * column 4 here too, or the corpus compares two different notions of position.
+     */
     let objectLine = 1;
-    let objectStarted = false;
-    const endField = (end) => {
-        chunks.push(text.slice(fieldStart, end));
-        const value = chunks.join('').trim();
-        chunks = [];
-        return value;
-    };
-    while (index < length) {
-        const char = text[index];
-        if (char === '!') {
-            // Preserve any field text seen before the comment, then resume after the
-            // newline. This is what lets `Zone1,  !- Name` work: the comment is not
-            // part of the value, but the value is not finished either.
-            chunks.push(text.slice(fieldStart, index));
-            const newline = text.indexOf('\n', index);
-            if (newline === -1) {
-                index = length;
-                fieldStart = length;
-                break;
-            }
-            index = newline + 1;
-            fieldStart = index;
-            line += 1;
-            if (!objectStarted && chunks.join('').trim() === '') {
-                chunks = [];
-                objectLine = line;
+    let objectColumn = 0;
+    let objectOffset = -1;
+    scan(text, {
+        statementStart(offset, line, column) {
+            objectLine = line;
+            objectColumn = column;
+            objectOffset = offset;
+        },
+        fieldText(start, end) {
+            chunks.push(text.slice(start, end));
+        },
+        fieldEnd() {
+            values.push(chunks.join('').trim());
+            chunks = [];
+        },
+        statementEnd(_end, unterminated) {
+            if (unterminated) {
+                // The scan closes the field the input ran out inside, so the trailing text arrived as the
+                // last value rather than as a leftover. Popping it leaves `values` holding exactly what a
+                // terminated statement would have held, which is what the message reads from.
+                const trailing = values.pop() ?? '';
+                if (trailing !== '' || values.length > 0) {
+                    report?.({
+                        message: `Unterminated object near "${trailing.slice(0, 40) || values[0]}" (missing ";")`,
+                        line: objectLine,
+                        code: 'ParseError',
+                        column: objectColumn || undefined,
+                        // `values` has not been shifted, because the shift happens on `;` and there was none,
+                        // so the type name is still at the front. Reporting it is what lets the corpus compare
+                        // this finding against Python's on `(code, line, typeName)`.
+                        typeName: values[0],
+                    });
+                }
+                values = [];
+                return;
             }
-            continue;
-        }
-        if (char === ',') {
-            values.push(endField(index));
-            objectStarted = true;
-            index += 1;
-            fieldStart = index;
-            continue;
-        }
-        if (char === ';') {
-            values.push(endField(index));
-            index += 1;
-            fieldStart = index;
             const typeName = values.shift() ?? '';
             if (typeName === '') {
-                report?.({ message: 'Object with no type name', line: objectLine });
+                report?.({
+                    message: 'Object with no type name',
+                    line: objectLine,
+                    column: objectColumn || undefined,
+                    code: 'ParseError',
+                });
             }
             else {
-                objects.push({ typeName, values, line: objectLine });
+                objects.push({
+                    typeName,
+                    values,
+                    line: objectLine,
+                    column: objectColumn || undefined,
+                    offset: objectOffset >= 0 ? objectOffset : undefined,
+                });
             }
             values = [];
-            objectStarted = false;
-            objectLine = line;
-            continue;
-        }
-        if (char === '\n') {
-            line += 1;
-            if (!objectStarted &&
-                chunks.join('').trim() === '' &&
-                text.slice(fieldStart, index).trim() === '') {
-                // Blank line before any object content: keep the start line current.
-                chunks = [];
-                fieldStart = index + 1;
-                objectLine = line;
-            }
-        }
-        index += 1;
-    }
-    const trailing = (chunks.join('') + text.slice(fieldStart, length)).trim();
-    if (trailing !== '' || values.length > 0) {
-        report?.({
-            message: `Unterminated object near "${trailing.slice(0, 40) || values[0]}" (missing ";")`,
-            line: objectLine,
-        });
-    }
+        },
+    });
     return objects;
 }
 //# sourceMappingURL=lexer.js.map

package/dist/parse/lexer.js.map

@@ -1 +1 @@
-{"version":3,"file":"lexer.js","sourceRoot":"","sources":["../../src/parse/lexer.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"lexer.js","sourceRoot":"","sources":["../../src/parse/lexer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAmEjC;;;;;;;;;;GAUG;AACH,MAAM,UAAU,GAAG,CAAC,IAAY,EAAE,UAAsB,EAAE;IACxD,MAAM,OAAO,GAAgB,EAAE,CAAC;IAChC,MAAM,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAEpC,qFAAqF;IACrF,IAAI,MAAM,GAAa,EAAE,CAAC;IAC1B,4EAA4E;IAC5E,IAAI,MAAM,GAAa,EAAE,CAAC;IAE1B;;;;;;OAMG;IACH,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,IAAI,YAAY,GAAG,CAAC,CAAC;IACrB,IAAI,YAAY,GAAG,CAAC,CAAC,CAAC;IAEtB,IAAI,CAAC,IAAI,EAAE;QACT,cAAc,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM;YACjC,UAAU,GAAG,IAAI,CAAC;YAClB,YAAY,GAAG,MAAM,CAAC;YACtB,YAAY,GAAG,MAAM,CAAC;QACxB,CAAC;QAED,SAAS,CAAC,KAAK,EAAE,GAAG;YAClB,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAC;QACtC,CAAC;QAED,QAAQ;YACN,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;YACpC,MAAM,GAAG,EAAE,CAAC;QACd,CAAC;QAED,YAAY,CAAC,IAAI,EAAE,YAAY;YAC7B,IAAI,YAAY,EAAE,CAAC;gBACjB,0FAA0F;gBAC1F,0FAA0F;gBAC1F,8EAA8E;gBAC9E,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,EAAE,IAAI,EAAE,CAAC;gBACpC,IAAI,QAAQ,KAAK,EAAE,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACzC,MAAM,EAAE,CAAC;wBACP,OAAO,EAAE,6BAA6B,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,iBAAiB;wBACzF,IAAI,EAAE,UAAU;wBAChB,IAAI,EAAE,YAAY;wBAClB,MAAM,EAAE,YAAY,IAAI,SAAS;wBACjC,sFAAsF;wBACtF,uFAAuF;wBACvF,6DAA6D;wBAC7D,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC;qBACpB,CAAC,CAAC;gBACL,CAAC;gBACD,MAAM,GAAG,EAAE,CAAC;gBACZ,OAAO;YACT,CAAC;YAED,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC;YACtC,IAAI,QAAQ,KAAK,EAAE,EAAE,CAAC;gBACpB,MAAM,EAAE,CAAC;oBACP,OAAO,EAAE,0BAA0B;oBACnC,IAAI,EAAE,UAAU;oBAChB,MAAM,EAAE,YAAY,IAAI,SAAS;oBACjC,IAAI,EAAE,YAAY;iBACnB,CAAC,CAAC;YACL,CAAC;iBAAM,CAAC;gBACN,OAAO,CAAC,IAAI,CAAC;oBACX,QAAQ;oBACR,MAAM;oBACN,IAAI,EAAE,UAAU;oBAChB,MAAM,EAAE,YAAY,IAAI,SAAS;oBACjC,MAAM,EAAE,YAAY,IAAI,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS;iBACrD,CAAC,CAAC;YACL,CAAC;YACD,MAAM,GAAG,EAAE,CAAC;QACd,CAAC;KACF,CAAC,CAAC;IAEH,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/parse/scan.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The IDF character rules, in one place.
+ *
+ * The grammar is small:
+ *   - `!` starts a comment running to the end of its line
+ *   - `,` separates fields
+ *   - `;` terminates a statement
+ *   - everything else is field text
+ *
+ * There are no string literals and no escape sequences, so a comma cannot occur inside a field
+ * value and an `!` always starts a comment. Real files depend on both.
+ *
+ * A hand-written character walk rather than a regex. The Python library matches objects with a
+ * `(?:[^;!]*(?:![^\n]*\n)?)*?` inner loop; that is a nested quantifier, so it backtracks badly on
+ * malformed input and cannot report where the problem was. A scan is about the same amount of
+ * code, is linear in the input, and always knows its line number.
+ *
+ * **Why this file exists at all.** Every position this library reports depends on the syntax layer
+ * and the model-building read agreeing about where a field begins and ends. Two implementations of
+ * "step over a comment between a separator and its value" that differ by one character put a
+ * finding on the wrong field, and that class of bug stays invisible until a file puts a comment
+ * somewhere unusual. The rules used to exist twice, once inside `lex` and once inside the
+ * `fieldLine` helper of `idf.ts`; both are now callers of this scan (research R3).
+ *
+ * **This module is internal and stays internal.** It is not exported from the package root. The
+ * syntax layer, which is public, is what a consumer outside the package reaches for; keeping the
+ * scan itself unexported is the reason the layer ships in core rather than beside the language
+ * service, because a package boundary drawn around both halves would have forced this file into a
+ * published export purely so the other half could reach it.
+ *
+ * @internal
+ */
+export {};
+//# sourceMappingURL=scan.d.ts.map

package/dist/parse/scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../src/parse/scan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG"}

package/dist/parse/scan.js

@@ -0,0 +1,177 @@
+/**
+ * The IDF character rules, in one place.
+ *
+ * The grammar is small:
+ *   - `!` starts a comment running to the end of its line
+ *   - `,` separates fields
+ *   - `;` terminates a statement
+ *   - everything else is field text
+ *
+ * There are no string literals and no escape sequences, so a comma cannot occur inside a field
+ * value and an `!` always starts a comment. Real files depend on both.
+ *
+ * A hand-written character walk rather than a regex. The Python library matches objects with a
+ * `(?:[^;!]*(?:![^\n]*\n)?)*?` inner loop; that is a nested quantifier, so it backtracks badly on
+ * malformed input and cannot report where the problem was. A scan is about the same amount of
+ * code, is linear in the input, and always knows its line number.
+ *
+ * **Why this file exists at all.** Every position this library reports depends on the syntax layer
+ * and the model-building read agreeing about where a field begins and ends. Two implementations of
+ * "step over a comment between a separator and its value" that differ by one character put a
+ * finding on the wrong field, and that class of bug stays invisible until a file puts a comment
+ * somewhere unusual. The rules used to exist twice, once inside `lex` and once inside the
+ * `fieldLine` helper of `idf.ts`; both are now callers of this scan (research R3).
+ *
+ * **This module is internal and stays internal.** It is not exported from the package root. The
+ * syntax layer, which is public, is what a consumer outside the package reaches for; keeping the
+ * scan itself unexported is the reason the layer ships in core rather than beside the language
+ * service, because a package boundary drawn around both halves would have forced this file into a
+ * published export purely so the other half could reach it.
+ *
+ * @internal
+ */
+const EXCLAMATION = 0x21;
+const COMMA = 0x2c;
+const SEMICOLON = 0x3b;
+const LINE_FEED = 0x0a;
+/**
+ * Walk IDF text, reporting what the handler asked for.
+ *
+ * One linear pass, no allocation of its own, and it never throws: text that violates the grammar
+ * is reported as what it is rather than stopped at.
+ *
+ * @internal
+ */
+export function scan(text, handler, options = {}) {
+    const length = text.length;
+    let index = options.from ?? 0;
+    let line = options.line ?? 1;
+    /** Offset of the current line's first character, which is what turns an offset into a column. */
+    let lineStart = index - ((options.column ?? 1) - 1);
+    /** Start of the current field's text run, moved past every comment that interrupts it. */
+    let fieldStart = index;
+    /** 0 for the type name, 1 for the first field after it. */
+    let fieldIndex = 0;
+    /** True once the current statement's first non-blank, non-comment character has been seen. */
+    let open = false;
+    /** First non-blank character of the current field's value, or -1 while it has none. */
+    let valueStart = -1;
+    /** One past the last non-blank character of the run `valueStart` falls in. */
+    let valueEnd = -1;
+    /** Line `valueStart` falls on. */
+    let valueLine = 1;
+    /** True once a comment has ended the run holding `valueStart`. */
+    let valueClosed = false;
+    /**
+     * Report the field the scan is inside, closed at `at`. False when a handler asked to stop.
+     *
+     * A field with no value text is positioned at `at`, which is the separator, the terminator, or
+     * the end of input that closed it. That is the offset a value would have begun at, because
+     * everything between the field's start and `at` was whitespace or comment.
+     */
+    const closeField = (at) => {
+        if (at > fieldStart && handler.fieldText?.(fieldStart, at) === false)
+            return false;
+        const empty = valueStart < 0;
+        const stop = handler.fieldEnd?.(fieldIndex, empty ? at : valueStart, empty ? at : valueEnd, empty ? line : valueLine) === false;
+        valueStart = -1;
+        valueEnd = -1;
+        valueClosed = false;
+        return !stop;
+    };
+    while (index < length) {
+        const code = text.charCodeAt(index);
+        if (code === EXCLAMATION) {
+            // Text seen before the comment still belongs to the field, and so does text after the line
+            // feed: the comment interrupts the field without ending it. This is what lets
+            // `Zone1,  !- Name` work, where the comment is no part of the value and the value is no part
+            // of the comment.
+            if (index > fieldStart && handler.fieldText?.(fieldStart, index) === false)
+                return;
+            const feed = text.indexOf('\n', index);
+            const end = feed === -1 ? length : feed;
+            if (handler.comment?.(index, end) === false)
+                return;
+            if (valueStart >= 0)
+                valueClosed = true;
+            if (feed === -1) {
+                fieldStart = length;
+                break;
+            }
+            index = feed + 1;
+            fieldStart = index;
+            line += 1;
+            lineStart = index;
+            continue;
+        }
+        const blank = isSpace(code);
+        if (!open && !blank) {
+            open = true;
+            if (handler.statementStart?.(index, line, index - lineStart + 1) === false)
+                return;
+        }
+        if (code === COMMA || code === SEMICOLON) {
+            if (!closeField(index))
+                return;
+            if (code === COMMA) {
+                if (handler.separator?.(index) === false)
+                    return;
+                fieldIndex += 1;
+            }
+            else {
+                if (handler.terminator?.(index) === false)
+                    return;
+                if (handler.statementEnd?.(index + 1, false) === false)
+                    return;
+                fieldIndex = 0;
+                open = false;
+            }
+            index += 1;
+            fieldStart = index;
+            continue;
+        }
+        if (code === LINE_FEED) {
+            line += 1;
+            lineStart = index + 1;
+        }
+        else if (!blank) {
+            if (valueStart < 0) {
+                valueStart = index;
+                valueEnd = index + 1;
+                valueLine = line;
+            }
+            else if (!valueClosed) {
+                valueEnd = index + 1;
+            }
+        }
+        index += 1;
+    }
+    // Input ran out inside a statement. Its last field is reported like any other, so a caller reads
+    // what was written rather than having to reconstruct it from the leftovers.
+    if (!open)
+        return;
+    if (!closeField(length))
+        return;
+    handler.statementEnd?.(length, true);
+}
+/**
+ * Whether a character is whitespace, by the same definition `String.prototype.trim` uses.
+ *
+ * A field's value is trimmed, so a scan that disagreed with `trim` about one character would put
+ * a region beside the value rather than on it. ASCII is one comparison; the rest of the set costs
+ * a branch nothing outside a comment ever takes.
+ */
+function isSpace(code) {
+    if (code < 0x80)
+        return code === 0x20 || (code >= 0x09 && code <= 0x0d);
+    return (code === 0xa0 ||
+        code === 0x1680 ||
+        (code >= 0x2000 && code <= 0x200a) ||
+        code === 0x2028 ||
+        code === 0x2029 ||
+        code === 0x202f ||
+        code === 0x205f ||
+        code === 0x3000 ||
+        code === 0xfeff);
+}
+//# sourceMappingURL=scan.js.map

package/dist/parse/scan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan.js","sourceRoot":"","sources":["../../src/parse/scan.ts"],"names":[],"mappings":"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"}

package/dist/syntax/classify.d.ts

@@ -0,0 +1,25 @@
+import type { SyntaxLayer } from './layer.js';
+import type { Token } from './tokens.js';
+/**
+ * Every character of the text, as tokens, in source order.
+ *
+ * Two things happen here that the layer deliberately does not pay to store.
+ *
+ * The first is `trivia`. Whitespace is the complement of the stored tokens, so storing it would
+ * roughly double the token count to hold something derivable by subtraction. This function fills
+ * each gap as it walks, which is what makes the layer's complete coverage observable (FR-016)
+ * without the layer carrying it: the sequence begins at offset 0, ends at `text.length`, and has
+ * no gap and no overlap anywhere between.
+ *
+ * The second is the line split. No yielded token crosses a line boundary (FR-047), while a stored
+ * `value` region may, because the format lets a field be written across two lines and real files
+ * do it. Every token encoding in use, the Language Server Protocol's included, expresses a token
+ * as a length on a single line, so a token spanning one cannot be encoded at all. The split adds
+ * tokens and moves no boundary, so the tiling holds exactly as before, and the stored region stays
+ * whole for everything that is not being drawn.
+ *
+ * A generator, so a consumer colouring a viewport stops where it stops rather than materialising
+ * four hundred thousand tokens to read the first fifty.
+ */
+export declare function classify(layer: SyntaxLayer): Iterable<Token>;
+//# sourceMappingURL=classify.d.ts.map

package/dist/syntax/classify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.d.ts","sourceRoot":"","sources":["../../src/syntax/classify.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,OAAO,KAAK,EAAE,KAAK,EAAa,MAAM,aAAa,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAiB,QAAQ,CAAC,KAAK,EAAE,WAAW,GAAG,QAAQ,CAAC,KAAK,CAAC,CAkC7D"}

package/dist/syntax/classify.js

@@ -0,0 +1,59 @@
+import { lineStartsOf } from './region.js';
+/**
+ * Every character of the text, as tokens, in source order.
+ *
+ * Two things happen here that the layer deliberately does not pay to store.
+ *
+ * The first is `trivia`. Whitespace is the complement of the stored tokens, so storing it would
+ * roughly double the token count to hold something derivable by subtraction. This function fills
+ * each gap as it walks, which is what makes the layer's complete coverage observable (FR-016)
+ * without the layer carrying it: the sequence begins at offset 0, ends at `text.length`, and has
+ * no gap and no overlap anywhere between.
+ *
+ * The second is the line split. No yielded token crosses a line boundary (FR-047), while a stored
+ * `value` region may, because the format lets a field be written across two lines and real files
+ * do it. Every token encoding in use, the Language Server Protocol's included, expresses a token
+ * as a length on a single line, so a token spanning one cannot be encoded at all. The split adds
+ * tokens and moves no boundary, so the tiling holds exactly as before, and the stored region stays
+ * whole for everything that is not being drawn.
+ *
+ * A generator, so a consumer colouring a viewport stops where it stops rather than materialising
+ * four hundred thousand tokens to read the first fifty.
+ */
+export function* classify(layer) {
+    const text = layer.text;
+    const tokens = layer.tokens;
+    const starts = tokens.starts;
+    const ends = tokens.ends;
+    // The layer's own line index, built once and shared with every position query made against it.
+    const lineStarts = lineStartsOf(layer);
+    /** The line the walk is on. It only ever moves forward, so the whole pass stays linear. */
+    let line = 0;
+    /** One token per line the span touches, split at each line start strictly inside it. */
+    function* perLine(from, to, kind) {
+        while (line + 1 < lineStarts.length && lineStarts[line + 1] <= from)
+            line += 1;
+        let at = from;
+        while (line + 1 < lineStarts.length && lineStarts[line + 1] < to) {
+            line += 1;
+            const boundary = lineStarts[line];
+            yield { start: at, end: boundary, kind };
+            at = boundary;
+        }
+        if (at < to)
+            yield { start: at, end: to, kind };
+    }
+    /** One past the last character yielded so far, which is where the next gap would begin. */
+    let covered = 0;
+    for (let index = 0; index < tokens.length; index += 1) {
+        const start = starts[index];
+        if (start > covered)
+            yield* perLine(covered, start, 'trivia');
+        const end = ends[index];
+        yield* perLine(start, end, tokens.kindAt(index));
+        covered = end;
+    }
+    if (covered < text.length)
+        yield* perLine(covered, text.length, 'trivia');
+}
+//# sourceMappingURL=classify.js.map

package/dist/syntax/classify.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify.js","sourceRoot":"","sources":["../../src/syntax/classify.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG3C;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,SAAS,CAAC,CAAC,QAAQ,CAAC,KAAkB;IAC1C,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;IACxB,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC;IAC5B,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAC7B,MAAM,IAAI,GAAG,MAAM,CAAC,IAAI,CAAC;IACzB,+FAA+F;IAC/F,MAAM,UAAU,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC;IAEvC,2FAA2F;IAC3F,IAAI,IAAI,GAAG,CAAC,CAAC;IAEb,wFAAwF;IACxF,QAAQ,CAAC,CAAC,OAAO,CAAC,IAAY,EAAE,EAAU,EAAE,IAAe;QACzD,OAAO,IAAI,GAAG,CAAC,GAAG,UAAU,CAAC,MAAM,IAAI,UAAU,CAAC,IAAI,GAAG,CAAC,CAAE,IAAI,IAAI;YAAE,IAAI,IAAI,CAAC,CAAC;QAChF,IAAI,EAAE,GAAG,IAAI,CAAC;QACd,OAAO,IAAI,GAAG,CAAC,GAAG,UAAU,CAAC,MAAM,IAAI,UAAU,CAAC,IAAI,GAAG,CAAC,CAAE,GAAG,EAAE,EAAE,CAAC;YAClE,IAAI,IAAI,CAAC,CAAC;YACV,MAAM,QAAQ,GAAG,UAAU,CAAC,IAAI,CAAE,CAAC;YACnC,MAAM,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;YACzC,EAAE,GAAG,QAAQ,CAAC;QAChB,CAAC;QACD,IAAI,EAAE,GAAG,EAAE;YAAE,MAAM,EAAE,KAAK,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC;IAClD,CAAC;IAED,2FAA2F;IAC3F,IAAI,OAAO,GAAG,CAAC,CAAC;IAChB,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QACtD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAE,CAAC;QAC7B,IAAI,KAAK,GAAG,OAAO;YAAE,KAAK,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;QAC9D,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAE,CAAC;QACzB,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QACjD,OAAO,GAAG,GAAG,CAAC;IAChB,CAAC;IACD,IAAI,OAAO,GAAG,IAAI,CAAC,MAAM;QAAE,KAAK,CAAC,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;AAC5E,CAAC"}