@idfkit/language 0.0.0

package/dist/explain.d.ts

@@ -0,0 +1,97 @@
+import { type DocsUrl, type FieldDescription, type ProsePool, type Region, type Schema } from '@idfkit/core';
+/**
+ * What the schema says about whatever the offset is on.
+ *
+ * Every member is reported rather than composed. The facts come from
+ * `describeObjectType`, the prose from the pool the caller supplied, and the manual location from
+ * `docsUrlForObject`; nothing here is derived from a field's name, which is the one thing FR-022
+ * forbids by name.
+ */
+export interface Explanation {
+    /**
+     * The region this explanation describes (FR-049).
+     *
+     * What a consumer highlights while the explanation is shown, so that the reader can see which
+     * characters the words are about. Carried rather than left to the consumer for the reason offers
+     * carry theirs: an editor's own word rules split `BuildingSurface:Detailed` at the colon and
+     * `Office Zone 1` at the spaces, and would highlight a fragment of each.
+     *
+     * It identifies a thing rather than something to draw, so it stays whole and may cross a line
+     * boundary (FR-050): a field written across two lines is ordinary in this format.
+     */
+    readonly region: Region;
+    /** What the offset is on. */
+    readonly of: 'objectType' | 'field';
+    /** The canonical type name. */
+    readonly typeName: string;
+    /** The schema field name, when `of` is `'field'`. */
+    readonly fieldName: string | undefined;
+    /**
+     * The schema's own prose, when the caller supplied the pool.
+     *
+     * The type's memo for a type name and the field's note for a field. `undefined` where no pool
+     * was supplied and where the pool carries none for this record: absence is reported as absence,
+     * never filled with a sentence made up from the name.
+     */
+    readonly prose: string | undefined;
+    /**
+     * The field's facts, exactly as `describeObjectType` produces them. Undefined for a type name.
+     *
+     * Also undefined for one field this package cannot describe, and it is worth naming rather than
+     * hiding. `describeObjectType` drops the type's positional first field, because Python's
+     * `get_field_names` drops it on the assumption that it is always the name. On the anonymous
+     * types it is a real field, and `GlobalGeometryRules.starting_vertex_position` is one an author
+     * edits by hand. Rebuilding a `FieldDescription` here would be a second copy of the schema's
+     * facts, which FR-029 forbids and which would drift from the reference page the reader is
+     * comparing against, so the structural facts are reported as absent and the field's own prose is
+     * still resolved. Closing the hole properly means changing `describeObjectType` in
+     * `@idfkit/core`, which this package does not own.
+     */
+    readonly field: FieldDescription | undefined;
+    /**
+     * Where the manual documents this, from `docsUrlForObject`.
+     *
+     * The type's page in both cases, because that is where the manual documents a field: it has no
+     * page of its own. `undefined` for a version the documentation site does not carry.
+     */
+    readonly docs: DocsUrl | undefined;
+}
+/**
+ * What the schema says here, or why it says nothing.
+ *
+ * The same discriminated shape as `CompletionResult`, for the same reason: "there is nothing here
+ * to explain" and "I could not consult a schema" are different states, and an editor that rendered
+ * them identically would teach the reader that the tool is broken in the first case and silently
+ * wrong in the second (FR-031).
+ */
+export type ExplanationResult = {
+    readonly status: 'ok';
+    readonly explanation: Explanation;
+} | {
+    readonly status: 'noSchema';
+} | {
+    readonly status: 'unknownType';
+    readonly typeName: string;
+} | {
+    readonly status: 'notApplicable';
+};
+/**
+ * What the thing under the cursor means, in the schema's own words.
+ *
+ * Bounded local work, like every other cursor answer: the cursor is placed by {@link contextAt},
+ * which scans one statement, and the answer then comes from the type, whose cost is the type
+ * rather than the file.
+ *
+ * The prose pool stays the caller's to load (FR-028). It is a parameter rather than something
+ * reached for, and this module imports it as a type alone, so a caller who never asks for prose
+ * never pays for it: passing nothing yields the structural facts with `prose: undefined`, which is
+ * a truthful absence rather than a sentence derived from the field's name.
+ *
+ * `schema` is written as possibly absent rather than required, because `'noSchema'` is a state
+ * FR-031 requires this to report and a signature that forbade the input would make it unreachable
+ * from typed code.
+ *
+ * Nothing throws, for any input.
+ */
+export declare function explainAt(text: string, offset: number, schema: Schema | undefined, prose?: ProsePool): ExplanationResult;
+//# sourceMappingURL=explain.d.ts.map

package/dist/explain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explain.d.ts","sourceRoot":"","sources":["../src/explain.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,OAAO,EACZ,KAAK,gBAAgB,EACrB,KAAK,SAAS,EACd,KAAK,MAAM,EACX,KAAK,MAAM,EACZ,MAAM,cAAc,CAAC;AAItB;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,6BAA6B;IAC7B,QAAQ,CAAC,EAAE,EAAE,YAAY,GAAG,OAAO,CAAC;IACpC,+BAA+B;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,qDAAqD;IACrD,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IACvC;;;;;;OAMG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC;;;;;;;;;;;;OAYG;IACH,QAAQ,CAAC,KAAK,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAC7C;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,SAAS,CAAC;CACpC;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,GACzB;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,WAAW,EAAE,WAAW,CAAA;CAAE,GAC5D;IAAE,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAA;CAAE,GAC/B;IAAE,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC7D;IAAE,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAA;CAAE,CAAC;AAKzC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,KAAK,CAAC,EAAE,SAAS,GAChB,iBAAiB,CAoEnB"}

package/dist/explain.js

@@ -0,0 +1,130 @@
+import { describeObjectType, docsUrlForObject, } from '@idfkit/core';
+import { contextAt } from './cursor.js';
+const NOT_APPLICABLE = { status: 'notApplicable' };
+const NO_SCHEMA = { status: 'noSchema' };
+/**
+ * What the thing under the cursor means, in the schema's own words.
+ *
+ * Bounded local work, like every other cursor answer: the cursor is placed by {@link contextAt},
+ * which scans one statement, and the answer then comes from the type, whose cost is the type
+ * rather than the file.
+ *
+ * The prose pool stays the caller's to load (FR-028). It is a parameter rather than something
+ * reached for, and this module imports it as a type alone, so a caller who never asks for prose
+ * never pays for it: passing nothing yields the structural facts with `prose: undefined`, which is
+ * a truthful absence rather than a sentence derived from the field's name.
+ *
+ * `schema` is written as possibly absent rather than required, because `'noSchema'` is a state
+ * FR-031 requires this to report and a signature that forbade the input would make it unreachable
+ * from typed code.
+ *
+ * Nothing throws, for any input.
+ */
+export function explainAt(text, offset, schema, prose) {
+    const context = contextAt(text, offset, schema);
+    // Inside a comment, and in the whitespace between two statements, there is nothing the schema
+    // has anything to say about. Reporting `'noSchema'` here would send a caller off to load one
+    // that would change this answer not at all.
+    if (context.at === 'comment' || context.at === 'betweenStatements')
+        return NOT_APPLICABLE;
+    if (schema === undefined)
+        return NO_SCHEMA;
+    // The region first, and the schema afterwards. An offset on a separator, on a terminator, or in
+    // the whitespace beside a value falls outside every region this statement holds, and answering
+    // it with the nearest field is the behaviour that makes a hover feel haunted (FR-049). The test
+    // is containment rather than a character test, because a region already ends where the value
+    // ends: it begins at the value's first non-blank character and stops after its last, so
+    // everything between two values, the comma included, is outside both.
+    const at = clampOffset(offset, text.length);
+    const region = describedRegion(context, at);
+    if (region === undefined)
+        return NOT_APPLICABLE;
+    const typeName = context.typeName;
+    if (typeName === undefined) {
+        return { status: 'unknownType', typeName: context.statement.typeNameText };
+    }
+    const type = schema.get(typeName);
+    // Unreachable through `resolve`, which only returns a name the schema holds, and kept because
+    // `describeObjectType` throws on a type the schema lacks and nothing here may throw (FR-030).
+    if (type === undefined)
+        return { status: 'unknownType', typeName };
+    const described = describeObjectType(schema, typeName, prose);
+    const docs = docsUrlForObject(typeName, schema.version, schema);
+    if (context.at === 'typeName') {
+        return {
+            status: 'ok',
+            explanation: {
+                region,
+                of: 'objectType',
+                typeName,
+                fieldName: undefined,
+                prose: described.memo,
+                field: undefined,
+                docs,
+            },
+        };
+    }
+    const fieldName = context.fieldName;
+    // Past the type's last field, with no extensible group to repeat. The schema defines no field
+    // here and so says nothing about one; that the field should not be there is a finding, and
+    // saying so is that finding's job rather than this one's.
+    if (fieldName === undefined)
+        return NOT_APPLICABLE;
+    const field = described.fields.find((candidate) => candidate.name === fieldName);
+    return {
+        status: 'ok',
+        explanation: {
+            region,
+            of: 'field',
+            typeName,
+            fieldName,
+            // `field.note` is the same lookup, and taking it from the description keeps one source for
+            // it. The fallback is the pool lookup for the one field the description cannot carry, which
+            // resolves an index the schema already holds rather than reproducing anything.
+            prose: field === undefined ? proseFor(type.p[fieldName]?.n, prose) : field.note,
+            field,
+            docs,
+        },
+    };
+}
+/**
+ * The region the explanation is about, or `undefined` when the offset is not on one.
+ *
+ * `at` is `'typeName'` or `'field'` by the time this is called, so the region is the statement's
+ * type name or the written field at the cursor's index. A field written empty has an empty region
+ * positioned between its separators, which contains no offset at all, and that is the right answer
+ * for it: there is no text there to explain.
+ */
+function describedRegion(context, offset) {
+    const region = context.at === 'typeName'
+        ? context.statement.typeName
+        : // `fieldIndex` is defined for every `'field'` context; the guard is what the compiler
+            // needs, and an offset on no field is not on a region either way.
+            context.statement.fields[context.fieldIndex ?? -1];
+    if (region === undefined)
+        return undefined;
+    return offset >= region.start && offset < region.end ? region : undefined;
+}
+/** Resolve a prose index against the pool. Nothing is hydrated when no pool was supplied. */
+function proseFor(index, prose) {
+    if (index === undefined || prose === undefined)
+        return undefined;
+    return prose[index];
+}
+/**
+ * Into `[0, max]`, whole. `NaN` lands at 0, since no position is nearer than another.
+ *
+ * The clamp `contextAt` applies (FR-032), repeated because it is private to the cursor module. A
+ * containment test measured against an unclamped offset would disagree with the context it is
+ * testing, and would report nothing for an offset a keystroke past the end of the text where the
+ * cursor answer describes the last character.
+ */
+function clampOffset(value, max) {
+    if (Number.isNaN(value))
+        return 0;
+    const whole = Math.trunc(value);
+    if (whole < 0)
+        return 0;
+    return whole > max ? max : whole;
+}
+//# sourceMappingURL=explain.js.map

package/dist/explain.js.map

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

package/dist/findings.d.ts

@@ -0,0 +1,58 @@
+import type { ParseDiagnostic, Region, Schema, SyntaxLayer, ValidationError } from '@idfkit/core';
+/**
+ * An existing finding with the region it concerns attached. Not a new finding.
+ *
+ * `F` stays whatever it was: a `ParseDiagnostic` or a `ValidationError`, unchanged, with two
+ * properties added beside it. The generic is what lets both travel through one path without either
+ * type being touched, which is the whole point of correlating here rather than at the source. FR-014
+ * forbids filtering or rewording a finding and FR-015 forbids changing what an existing caller
+ * receives; both hold structurally, because nothing on the read path knows this module exists.
+ */
+export type PositionedFinding<F> = F & {
+    /** The region the finding concerns. */
+    readonly region: Region;
+    /** Whether the region selects the field or falls back to the statement. */
+    readonly precision: 'field' | 'statement';
+};
+/**
+ * Read text, validate what it produced, and position every finding from both.
+ *
+ * One parse, one validation, one scan, in that order, and then the correlation below. A consumer
+ * that already holds findings from its own run should call {@link position} instead and keep its
+ * parse; this exists for the consumer that has only text.
+ *
+ * Reading findings come first and validation findings after, which is the order in which the two
+ * runs produced them. Neither list is filtered: a value that is both unreadable and invalid is two
+ * findings here because it was two findings before.
+ *
+ * @example
+ * ```ts
+ * for (const finding of findingsIn(text, schema)) {
+ *   const { line, column } = lineColumnAt({ text }, finding.region.start);
+ *   console.log(`${line}:${column}`, finding.message);
+ * }
+ * ```
+ */
+export declare function findingsIn(text: string, schema: Schema): readonly PositionedFinding<ParseDiagnostic | ValidationError>[];
+/**
+ * Attach a region to each of a set of findings already produced.
+ *
+ * Exposed separately from {@link findingsIn} so a consumer holding findings from its own parse and
+ * its own validation pays for one scan rather than for a second read of the same text.
+ *
+ * Two families of finding arrive here and they are positioned by different routes, because they
+ * know different things. A reading finding was made by the scanner and already names a line, and
+ * often a column, so it is placed directly at what the scanner saw. A validation finding was made
+ * from a document and names an object by type and name, never a place, so it is correlated against
+ * the statement index below.
+ *
+ * A finding of neither shape, or one naming something this text does not contain, still comes back
+ * with a region: an empty one at the start of the text, saying as little as is actually known. SC-004
+ * asks for a region on every finding and zero omitted, and dropping the ones that were hard would
+ * satisfy the count while defeating the point.
+ *
+ * Findings are returned in the order they were given, so a caller can zip the result against its
+ * own list.
+ */
+export declare function position<F extends object>(findings: readonly F[], layer: SyntaxLayer, schema: Schema): readonly PositionedFinding<F>[];
+//# sourceMappingURL=findings.d.ts.map

package/dist/findings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findings.d.ts","sourceRoot":"","sources":["../src/findings.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,eAAe,EACf,MAAM,EACN,MAAM,EAGN,WAAW,EACX,eAAe,EAChB,MAAM,cAAc,CAAC;AAEtB;;;;;;;;GAQG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,CAAC,GAAG;IACrC,uCAAuC;IACvC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,2EAA2E;IAC3E,QAAQ,CAAC,SAAS,EAAE,OAAO,GAAG,WAAW,CAAC;CAC3C,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GACb,SAAS,iBAAiB,CAAC,eAAe,GAAG,eAAe,CAAC,EAAE,CAYjE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,EACvC,QAAQ,EAAE,SAAS,CAAC,EAAE,EACtB,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,MAAM,GACb,SAAS,iBAAiB,CAAC,CAAC,CAAC,EAAE,CAiBjC"}

package/dist/findings.js

@@ -0,0 +1,325 @@
+import { offsetAt, parseIdf, scanIdf, validateDocument } from '@idfkit/core';
+/**
+ * Read text, validate what it produced, and position every finding from both.
+ *
+ * One parse, one validation, one scan, in that order, and then the correlation below. A consumer
+ * that already holds findings from its own run should call {@link position} instead and keep its
+ * parse; this exists for the consumer that has only text.
+ *
+ * Reading findings come first and validation findings after, which is the order in which the two
+ * runs produced them. Neither list is filtered: a value that is both unreadable and invalid is two
+ * findings here because it was two findings before.
+ *
+ * @example
+ * ```ts
+ * for (const finding of findingsIn(text, schema)) {
+ *   const { line, column } = lineColumnAt({ text }, finding.region.start);
+ *   console.log(`${line}:${column}`, finding.message);
+ * }
+ * ```
+ */
+export function findingsIn(text, schema) {
+    // Never strict: a strict read throws on the first finding, and a caller asking for every finding
+    // in a file is asking for the file to be described rather than rejected.
+    const { document, diagnostics } = parseIdf(text, schema, { strict: false });
+    const validation = validateDocument(document);
+    const findings = [
+        ...diagnostics,
+        ...validation.errors,
+        ...validation.warnings,
+        ...validation.info,
+    ];
+    return position(findings, scanIdf(text), schema);
+}
+/**
+ * Attach a region to each of a set of findings already produced.
+ *
+ * Exposed separately from {@link findingsIn} so a consumer holding findings from its own parse and
+ * its own validation pays for one scan rather than for a second read of the same text.
+ *
+ * Two families of finding arrive here and they are positioned by different routes, because they
+ * know different things. A reading finding was made by the scanner and already names a line, and
+ * often a column, so it is placed directly at what the scanner saw. A validation finding was made
+ * from a document and names an object by type and name, never a place, so it is correlated against
+ * the statement index below.
+ *
+ * A finding of neither shape, or one naming something this text does not contain, still comes back
+ * with a region: an empty one at the start of the text, saying as little as is actually known. SC-004
+ * asks for a region on every finding and zero omitted, and dropping the ones that were hard would
+ * satisfy the count while defeating the point.
+ *
+ * Findings are returned in the order they were given, so a caller can zip the result against its
+ * own list.
+ */
+export function position(findings, layer, schema) {
+    // Built per call rather than cached against the layer: it costs one pass over the statements and
+    // a couple of string operations each, against a parse and a validation run that have already
+    // happened. A cache here would be state, and this package holds none.
+    const index = indexStatements(layer, schema);
+    return findings.map((finding) => {
+        const placed = isValidationShaped(finding)
+            ? placeValidation(finding, occurrenceOf(finding), schema, index)
+            : isParseShaped(finding)
+                ? placeParse(finding, layer)
+                : undefined;
+        return {
+            ...finding,
+            region: placed?.region ?? NOWHERE,
+            precision: placed?.precision ?? 'statement',
+        };
+    });
+}
+/**
+ * Where a finding lands when nothing in the text answers to it.
+ *
+ * Empty and at the start, which is what an editor renders as a file-level diagnostic. A region
+ * covering the whole text would be a claim about where the problem is, and there is no such claim
+ * to make.
+ */
+const NOWHERE = { start: 0, end: 0 };
+function indexStatements(layer, schema) {
+    const byName = new Map();
+    const byOrdinal = new Map();
+    // The schema hydrates a definition on every `get`, and a file holds thousands of statements of a
+    // few hundred types, so the answer to "is this type named?" is worth keeping.
+    const named = new Map();
+    for (const statement of layer.statements) {
+        const type = fold(statement.typeNameText);
+        let ofType = byOrdinal.get(type);
+        if (ofType === undefined) {
+            ofType = [];
+            byOrdinal.set(type, ofType);
+        }
+        ofType.push(statement);
+        let isNamed = named.get(type);
+        if (isNamed === undefined) {
+            isNamed = schema.get(statement.typeNameText)?.anon !== 1;
+            named.set(type, isNamed);
+        }
+        if (!isNamed)
+            continue;
+        // The name is the first field after the type name, which is what `Statement.fields` indexes
+        // from zero and what `parseIdf` reads the object's name out of.
+        const written = statement.fields[0];
+        if (written === undefined)
+            continue;
+        const key = nameKey(type, fold(layer.text.slice(written.start, written.end).trim()));
+        // First occurrence wins, matching `addRaw`: the object the document kept is the first one
+        // written, so a finding about this type and name is a finding about this statement.
+        if (!byName.has(key))
+            byName.set(key, statement);
+    }
+    return { byName, byOrdinal };
+}
+// ---------------------------------------------------------------------------
+// Validation findings, which name an object and are correlated
+// ---------------------------------------------------------------------------
+function placeValidation(finding, occurrence, schema, index) {
+    const statement = correlate(finding, occurrence, index);
+    if (statement === undefined)
+        return undefined;
+    // A finding with no field concerns the object itself: an unknown type, a singleton written twice.
+    // It selects the type name, which is the part of the statement that identifies it and the only
+    // part short enough to underline.
+    if (finding.field === undefined) {
+        return { region: statement.typeName, precision: 'statement' };
+    }
+    const type = schema.get(finding.objType);
+    const at = type === undefined ? undefined : fieldIndexOf(type, finding.field, occurrence.index);
+    // A field the schema does not define, or one whose repeat the finding could not say, falls back
+    // to the whole statement and says so. Guessing a position for it would put an underline under a
+    // value that is not the one complained about, which reads as correct and is not.
+    if (at === undefined)
+        return { region: statement.region, precision: 'statement' };
+    const region = statement.fields[at];
+    // Past what was written: the field is absent from the text, which is exactly what a missing
+    // required field is. There is nothing to select, so the statement stands in.
+    if (region === undefined)
+        return { region: statement.region, precision: 'statement' };
+    // A field written blank keeps an empty region between its two commas, and that is still the right
+    // place: it is where the value would have gone, and where an editor puts the caret to type it.
+    return { region, precision: 'field' };
+}
+/** The statement a validation finding is about, by name when it has one and by ordinal when it does not. */
+function correlate(finding, occurrence, index) {
+    const type = fold(finding.objType);
+    if (finding.objName !== '') {
+        const named = index.byName.get(nameKey(type, fold(finding.objName)));
+        if (named !== undefined)
+            return named;
+    }
+    const ofType = index.byOrdinal.get(type);
+    if (ofType === undefined)
+        return undefined;
+    // `objName` is documented as empty for anonymous objects, which is the signal to use the ordinal.
+    // The finding does not carry one, so a caller that knows it supplies it and everything else lands
+    // on the first statement of the type. That is exact for the singletons nearly every anonymous
+    // type is, and it is the closest available answer for the few that are not.
+    return ofType[occurrence.ordinal ?? 0];
+}
+/**
+ * The positional index a schema field name occupies, or `undefined` when the schema has no answer.
+ *
+ * Positional order is `SlimType.f`, which is the IDD order and includes the name at index 0 for a
+ * named type. `Statement.fields` is indexed from the first field after the type name, so a fixed
+ * field's index into it is simply its position in `f` for both named and anonymous types: on a
+ * named type index 0 is the name, and on an anonymous one index 0 is the first real field, which is
+ * what `f` holds in each case.
+ *
+ * An extensible field lives in the repeat group instead, which begins where the fixed fields end.
+ * The arithmetic is the one place this can go wrong quietly: a finding about the ninth vertex of a
+ * surface positioned at the first looks plausible in a screenshot and is useless in an editor. Worked
+ * on `BuildingSurface:Detailed`, whose eleven fixed fields are followed by repeats three wide, the
+ * x coordinate of the ninth vertex is `11 + 8 * 3 + 0`, which is field 35 of the statement.
+ */
+function fieldIndexOf(type, field, repeat) {
+    const fixed = type.f.indexOf(field);
+    if (fixed !== -1)
+        return fixed;
+    const extensible = type.x;
+    if (extensible === undefined)
+        return undefined;
+    const offsetWithinGroup = extensible.fields.indexOf(field);
+    if (offsetWithinGroup === -1)
+        return undefined;
+    // Which repeat is not something a `ValidationError` can say, and a wrong repeat is worse than no
+    // position at all, so without one this declines to answer and the caller falls back to the
+    // statement.
+    if (repeat === undefined)
+        return undefined;
+    const fixedCount = type.f.length;
+    const groupWidth = extensible.fields.length;
+    return fixedCount + repeat * groupWidth + offsetWithinGroup;
+}
+// ---------------------------------------------------------------------------
+// Reading findings, which name a place and are used as they are
+// ---------------------------------------------------------------------------
+/**
+ * Where a reading finding sits, from the line and column the scanner recorded.
+ *
+ * Correlation is not used and must not be: a duplicate-name finding names a type and a name that
+ * belong to the statement ABOVE the one it is about, so correlating it would underline the wrong
+ * object. The scanner saw the offending statement and said where it was, and that answer is better
+ * than any reconstruction of it.
+ *
+ * A finding whose column resolves to the statement's own first character is about the statement, and
+ * every finding `lex` and `parseIdf` produce about a statement carries one. A finding carrying only
+ * a line is about a field on that line, which is what the `InvalidField` diagnostic is; it becomes
+ * field-precise when exactly one field begins on that line, and stays statement-precise when several
+ * do, because then which one is meant is not recoverable.
+ */
+function placeParse(finding, layer) {
+    const span = lineSpan(layer, finding.line);
+    const statement = statementNear(layer, span);
+    if (statement === undefined)
+        return undefined;
+    if (finding.column !== undefined) {
+        const at = offsetAt(layer, { line: finding.line, column: finding.column });
+        if (at === statement.region.start) {
+            return { region: statement.typeName, precision: 'statement' };
+        }
+    }
+    const field = soleFieldOn(statement, span);
+    return field === undefined
+        ? { region: statement.region, precision: 'statement' }
+        : { region: field, precision: 'field' };
+}
+/** The statement a line falls in, or the one beginning later on it when the line falls between two. */
+function statementNear(layer, span) {
+    const statements = layer.statements;
+    const at = lastStartingAtOrBefore(statements, span.start);
+    const containing = at === -1 ? undefined : statements[at];
+    if (containing !== undefined && span.start < containing.region.end)
+        return containing;
+    // Between two statements, which is where a finding on the blank line above a statement lands.
+    const next = statements[at + 1];
+    return next !== undefined && next.region.start <= span.end ? next : containing;
+}
+/** The one field beginning on this line, or `undefined` when none or several do. */
+function soleFieldOn(statement, span) {
+    let found;
+    for (const field of statement.fields) {
+        if (field.start < span.start || field.start > span.end)
+            continue;
+        if (found !== undefined)
+            return undefined;
+        found = field;
+    }
+    return found;
+}
+/** Index of the last statement beginning at or before `offset`, or -1 when none does. */
+function lastStartingAtOrBefore(statements, offset) {
+    let low = 0;
+    let high = statements.length - 1;
+    let found = -1;
+    while (low <= high) {
+        const middle = (low + high) >> 1;
+        if (statements[middle].region.start <= offset) {
+            found = middle;
+            low = middle + 1;
+        }
+        else {
+            high = middle - 1;
+        }
+    }
+    return found;
+}
+/**
+ * The offsets a 1-based line begins and ends at, the ending one being the line break itself.
+ *
+ * `offsetAt` clamps a column past the end of its line to that break, so asking for an impossible
+ * column is how the end is found without a second index of the text.
+ */
+function lineSpan(layer, line) {
+    return {
+        start: offsetAt(layer, { line, column: 1 }),
+        end: offsetAt(layer, { line, column: Number.MAX_SAFE_INTEGER }),
+    };
+}
+// ---------------------------------------------------------------------------
+// Telling the two shapes apart
+// ---------------------------------------------------------------------------
+/**
+ * A `ValidationError` names an object type; nothing else this positions does.
+ *
+ * Structural rather than nominal because `position` is generic over the finding, which is what keeps
+ * both types unmodified. The two shapes are disjoint on this property in both libraries.
+ */
+function isValidationShaped(finding) {
+    return typeof finding.objType === 'string';
+}
+/** A `ParseDiagnostic` names a line. Checked after the above, since a validation finding names none. */
+function isParseShaped(finding) {
+    return typeof finding.line === 'number';
+}
+/** Whatever a caller attached to say which occurrence a finding is about. See {@link Occurrence}. */
+function occurrenceOf(finding) {
+    const carried = finding;
+    return {
+        ordinal: typeof carried.ordinal === 'number' ? carried.ordinal : undefined,
+        index: typeof carried.index === 'number' ? carried.index : undefined,
+    };
+}
+/** Case folding, as EnergyPlus resolves a type name and as `IdfCollection` keys a name. */
+function fold(value) {
+    return value.toLowerCase();
+}
+/**
+ * The two halves of the name key, joined by a character neither of them can contain.
+ *
+ * An object name routinely holds spaces, commas and punctuation, so the separator is the one
+ * character IDF text cannot carry at all. Joining on anything a name may hold would let two
+ * different pairs produce one key.
+ */
+function nameKey(type, name) {
+    return `${type}${SEPARATOR}${name}`;
+}
+/**
+ * The NUL character itself, written as a constant rather than as an escape inside the template.
+ *
+ * `\u0000` inside a template literal needs one backslash, and a second one turns it into the
+ * six printable characters `\u0000`, which a name may perfectly well contain: the join would then
+ * be ambiguous in exactly the way the doc comment above says it is not.
+ */
+const SEPARATOR = '\u0000';
+//# sourceMappingURL=findings.js.map

package/dist/findings.js.map

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