@idfkit/language 0.0.0

package/dist/cursor.js

@@ -0,0 +1,286 @@
+/**
+ * Where the cursor is, found by scanning outwards from it.
+ *
+ * **This never builds or consults a `SyntaxLayer`, and it must not start.** Building a layer to
+ * answer a cursor is the reparse the whole design exists to avoid: it costs the file, on a
+ * keystroke, for an answer that concerns one statement. The committed measurement asks the same
+ * question of a large model and of a file a hundredth its size and requires the two to come out
+ * within a small factor, which is a check a reparse cannot pass on any machine.
+ *
+ * The method is a backward scan to the nearest semicolon that is not inside a comment, then a
+ * forward scan over that one statement. Both halves are sound only because of what this grammar
+ * lacks: IDF has no nesting, no string literals and no escape sequences, so a semicolon terminates
+ * a statement unconditionally unless a comment swallowed it, and a comment is an exclamation mark
+ * running to the end of its line. Deciding whether a candidate semicolon is real therefore costs
+ * the length of its line, and finding the statement costs the distance back to the previous real
+ * terminator. Neither number grows with the file. Almost no other grammar would permit this, and
+ * a language that gained a string literal would break it silently, so the property is stated here
+ * rather than left for a reader to rediscover.
+ *
+ * The honest bound is the distance back to the previous real terminator rather than the length of
+ * the statement. Those are the same number in ordinary files and differ in one real case: a cursor
+ * in the first statement of a file that opens with a large comment header scans back through the
+ * header. Headers are small, and the case is still linear with a tiny constant.
+ *
+ * Nothing throws, for any input. An offset outside `[0, text.length]` is clamped into range rather
+ * than refused (FR-032): a cursor arrives from an editor that may be a keystroke ahead of the text
+ * it was measured against, and answering about the nearest character beats answering nothing.
+ *
+ * The schema is optional. Without one the context still reports the statement, the part, and the
+ * field index, which is what positions a finding about a type no schema defines.
+ */
+export function contextAt(text, offset, schema) {
+    const at = clampOffset(offset, text.length);
+    const scanned = scanStatement(text, statementScanStart(text, at), at);
+    const statement = scanned.statement ?? emptyStatementAt(at);
+    const part = partOf(scanned);
+    const fieldIndex = part === 'field' ? scanned.slot - 1 : undefined;
+    const typeName = schema?.resolve(statement.typeNameText);
+    const type = typeName === undefined ? undefined : schema?.get(typeName);
+    const fieldName = type === undefined || fieldIndex === undefined ? undefined : fieldNameAt(type, fieldIndex);
+    return { statement, at: part, fieldIndex, typeName, fieldName };
+}
+/**
+ * The schema field name at a positional index, or `undefined` past the end of the type.
+ *
+ * Positional order is the schema's own: the fixed fields in `f`, whose index 0 is the name on a
+ * named type, and then the extensible group repeating its `fields` for as long as values were
+ * written. This mirrors how `parseIdf` maps positional values onto named fields, deliberately and
+ * exactly, because a cursor that disagreed with the reader about which field it was in would offer
+ * the neighbouring field's values.
+ *
+ * @internal
+ */
+export function fieldNameAt(type, index) {
+    if (index < 0)
+        return undefined;
+    const fixed = type.f;
+    if (index < fixed.length)
+        return fixed[index];
+    const extensible = type.x;
+    const width = extensible?.fields.length ?? 0;
+    if (extensible === undefined || width === 0)
+        return undefined;
+    return extensible.fields[(index - fixed.length) % width];
+}
+/** Which part of the statement the scan put the offset on. */
+function partOf(scanned) {
+    // A comment wins over everything, including the field it interrupts: nothing completes and
+    // nothing explains inside one, whether it sits between two statements or in the middle of a
+    // field's value.
+    if (scanned.inComment)
+        return 'comment';
+    // No statement had opened by the time the scan passed the offset, so the offset is in the
+    // whitespace after a terminator and before whatever comes next, which includes trailing
+    // whitespace at end of file. That is the state in which a new statement is beginning.
+    if (scanned.statement === undefined)
+        return 'betweenStatements';
+    return scanned.slot === 0 ? 'typeName' : 'field';
+}
+/**
+ * The statement a cursor is beginning to write, standing in for one that is not there yet.
+ *
+ * `CursorContext.statement` is not optional, and making it optional to describe an empty line
+ * would push a branch onto every consumer to serve the one state in which there is nothing to
+ * describe. An empty statement at the cursor is the truthful alternative: it selects nothing,
+ * which is exactly the region an offer inserted here would replace, and it reports
+ * `unterminated`, because a statement nobody has written carries no terminator.
+ */
+function emptyStatementAt(offset) {
+    const region = { start: offset, end: offset };
+    return { region, typeName: region, typeNameText: '', fields: [], unterminated: true };
+}
+/**
+ * Offset to begin the forward scan at: one past the nearest real terminator before `offset`.
+ *
+ * Backwards through the semicolons with `lastIndexOf`, which is a native scan rather than a
+ * character loop, testing each candidate for comment membership and skipping the ones a comment
+ * swallowed. A file with no terminator before the offset starts at zero, which is the only other
+ * place a statement can begin.
+ */
+function statementScanStart(text, offset) {
+    for (let at = offset - 1; at >= 0; at -= 1) {
+        const found = text.lastIndexOf(';', at);
+        if (found < 0)
+            return 0;
+        if (!insideComment(text, found))
+            return found + 1;
+        // Step past the one a comment swallowed and keep looking. `at -= 1` runs next, so a candidate
+        // at offset zero leaves the loop rather than finding itself again.
+        at = found;
+    }
+    return 0;
+}
+/**
+ * Whether the character at `index` sits inside a comment.
+ *
+ * Back to the start of its line, then forward for an exclamation mark before it. There are no
+ * string literals and no escapes, so an exclamation mark on the line before this character always
+ * opened a comment that is still open here, and one line is all it costs to know.
+ *
+ * The forward search is what keeps that promise. `lastIndexOf('!', index)` answers the same
+ * question and reads the whole prefix to do it whenever the file holds no exclamation mark before
+ * `index`, which is every position in a machine-written file that carries no comments at all: the
+ * cost then grows with how far into the file the cursor is, which is precisely what this module
+ * exists not to do. Searching forward from the line's own start stops at the line's end instead.
+ */
+function insideComment(text, index) {
+    const lineStart = index === 0 ? 0 : text.lastIndexOf('\n', index - 1) + 1;
+    const opened = text.indexOf('!', lineStart);
+    return opened !== -1 && opened <= index;
+}
+const EXCLAMATION = 0x21;
+const COMMA = 0x2c;
+const SEMICOLON = 0x3b;
+/**
+ * Read one statement forward from `from`, stopping as soon as the offset is placed.
+ *
+ * A second implementation of the character rules `@idfkit/core`'s internal scan already holds, and
+ * that is a deliberate cost rather than an oversight. The scan is internal to core on purpose, so
+ * that the syntax layer and the model-building read cannot drift apart; reaching it from here
+ * would mean publishing it, which is the hazard that decision exists to prevent. The rules
+ * reproduced here are the four that matter, and the field bounds are computed exactly as the layer
+ * computes them, so that a region reported by a cursor and a region reported by a finding select
+ * the same characters.
+ *
+ * The pass stops at the statement's terminator, or at end of input, or as soon as it is past the
+ * offset with nothing open, which is what keeps the cost the statement's rather than the file's.
+ */
+function scanStatement(text, from, offset) {
+    const length = text.length;
+    /** 0 for the type name, 1 for the first field after it. */
+    let fieldIndex = 0;
+    /** True once the statement's first non-blank, non-comment character has been seen. */
+    let open = false;
+    /** Where that character was. */
+    let openedAt = 0;
+    /** 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;
+    /** True once a comment has ended the run holding `valueStart`. */
+    let valueClosed = false;
+    let typeName = { start: from, end: from };
+    const fields = [];
+    let inComment = false;
+    let slot = 0;
+    let statement;
+    /**
+     * Record the field the scan is inside, closed at `at`.
+     *
+     * A field with no value text gets an empty region at `at`, the separator or terminator or end of
+     * input that closed it, because everything before it was whitespace or comment. That is what
+     * keeps positional indexing sound through a blank slot in the middle of an extensible group.
+     *
+     * A field written on both sides of a comment that interrupts it keeps the first run alone, which
+     * is what the layer stores, so a value region and a comment region can never overlap.
+     */
+    const closeField = (at) => {
+        const region = valueStart < 0 ? { start: at, end: at } : { start: valueStart, end: valueEnd };
+        if (fieldIndex === 0)
+            typeName = region;
+        else
+            fields.push(region);
+        valueStart = -1;
+        valueEnd = -1;
+        valueClosed = false;
+    };
+    const finish = (end, unterminated) => ({
+        region: { start: openedAt, end },
+        typeName,
+        typeNameText: text.slice(typeName.start, typeName.end),
+        fields,
+        unterminated,
+    });
+    let index = from;
+    while (index < length) {
+        // Nothing has opened and the offset is behind us, so no statement contains it and none that
+        // opens later can. Every comment that could hold the offset began at or before it and has
+        // already been tested.
+        if (!open && index > offset)
+            break;
+        const code = text.charCodeAt(index);
+        if (code === EXCLAMATION) {
+            const feed = text.indexOf('\n', index);
+            const end = feed === -1 ? length : feed;
+            // Inclusive at both ends. A cursor on the exclamation mark is in the comment it opens, and a
+            // cursor one past its last character is at the end of the comment's text rather than in the
+            // whitespace of the next line: typing there extends the comment.
+            if (offset >= index && offset <= end)
+                inComment = true;
+            // The comment ends the run holding the value but not the field, so `Zone1, !- Name` leaves
+            // the value at `Zone1` and text after the line feed still belongs to the same field.
+            if (valueStart >= 0)
+                valueClosed = true;
+            if (feed === -1)
+                break;
+            index = feed + 1;
+            continue;
+        }
+        const blank = isSpace(code);
+        if (!open && !blank) {
+            open = true;
+            openedAt = index;
+        }
+        if (code === COMMA || code === SEMICOLON) {
+            closeField(index);
+            if (code === SEMICOLON) {
+                statement = finish(index + 1, false);
+                break;
+            }
+            if (index < offset)
+                slot += 1;
+            fieldIndex += 1;
+            index += 1;
+            continue;
+        }
+        if (!blank) {
+            if (valueStart < 0) {
+                valueStart = index;
+                valueEnd = index + 1;
+            }
+            else if (!valueClosed) {
+                valueEnd = index + 1;
+            }
+        }
+        index += 1;
+    }
+    // Input ran out inside a statement. Its last field is closed like any other, so the cursor reads
+    // what was written rather than reconstructing it from the leftovers, and the statement says it
+    // runs to the end.
+    if (statement === undefined && open) {
+        closeField(length);
+        statement = finish(length, true);
+    }
+    return { statement, inComment, slot };
+}
+/**
+ * Whether a character is whitespace, by the definition `String.prototype.trim` uses.
+ *
+ * The same set the core scan tests, character for character. A field's value is trimmed, so a
+ * disagreement about one character would put a region beside a value rather than on it, and the
+ * cursor and the syntax layer would then report different bounds for the same field.
+ */
+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);
+}
+/** Into `[0, max]`, whole. `NaN` lands at 0, since no position is nearer than another. */
+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=cursor.js.map

package/dist/cursor.js.map

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

package/dist/declaration.d.ts

@@ -0,0 +1,70 @@
+import { type IdfDocument, type Region, type Schema } from '@idfkit/core';
+/** Where one object declares the name the cursor is on. */
+export interface Declaration {
+    /**
+     * The region where the name is declared, meaning the name field of the declaring statement.
+     *
+     * A region in the text this was asked about, not in the document: the document holds no
+     * positions, and it is the text the reader is looking at. It identifies a thing rather than
+     * something to draw, so it stays whole and may cross a line boundary (FR-050).
+     */
+    readonly region: Region;
+    /** The declaring statement's canonical type. */
+    readonly typeName: string;
+}
+/**
+ * What the value under the cursor names, or why it names nothing.
+ *
+ * The same discriminated shape as `CompletionResult`, for the same reason: "this value names
+ * nothing that exists" and "I could not consult a schema" are different states, and a consumer
+ * that wants to tell a reader why nothing happened has the reason (FR-031).
+ *
+ * `'ok'` with no declarations is a legitimate state and a different one from all three below: it
+ * says the field points into a reference list and nothing in the document declares this name.
+ * Where the name is declared nowhere, none is reported and none is guessed at; the
+ * dangling-reference finding is what tells the reader why.
+ */
+export type DeclarationResult = {
+    readonly status: 'ok';
+    readonly declarations: readonly Declaration[];
+} | {
+    readonly status: 'noSchema';
+} | {
+    readonly status: 'unknownType';
+    readonly typeName: string;
+} | {
+    readonly status: 'notApplicable';
+};
+/**
+ * Where the name under the cursor is declared.
+ *
+ * Two steps, and keeping them apart is what keeps this honest. Which objects declare the name is
+ * resolved against the caller's document, by the two rules the model itself uses and no third one
+ * (FR-029): the object's own name, when its type's `nref` contributes to a list this field points
+ * into, and an ordinary field's value, when that field's `ref` does. Only then is the declaring
+ * statement located in the text, by looking for the name the document holds and confirming with a
+ * cursor context that the match really is that type's declaring field. So the text is never
+ * searched for a string that happens to match: it is searched for a name the document has already
+ * said is declared, and a match that turns out to be a value somewhere else is discarded.
+ *
+ * The document is the caller's, exactly as it is for reference completion, and for the same reason
+ * (research R9): declarations are a whole-document fact, every consumer already holds a document,
+ * and parsing one here would put the eighty milliseconds this design exists to avoid back on the
+ * keystroke path. A document a keystroke behind the text is the correct input rather than a stale
+ * one.
+ *
+ * **Honest bound.** Locating a declaration reads the text rather than one statement of it, because
+ * "every declaration" is a question about the whole file and cannot be answered from a bounded
+ * local scan. The reading is `String.prototype.indexOf`, a native scan of a few hundred kilobytes
+ * costing a small fraction of a millisecond, plus one bounded cursor context per candidate match,
+ * and no layer is built and no document is parsed. It is stated here rather than left for a reader
+ * to discover in a profile.
+ *
+ * `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 declarationAt(text: string, offset: number, schema: Schema | undefined, document: IdfDocument): DeclarationResult;
+//# sourceMappingURL=declaration.d.ts.map

package/dist/declaration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"declaration.d.ts","sourceRoot":"","sources":["../src/declaration.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,MAAM,EACX,KAAK,MAAM,EAEZ,MAAM,cAAc,CAAC;AAItB,2DAA2D;AAC3D,MAAM,WAAW,WAAW;IAC1B;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,gDAAgD;IAChD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,iBAAiB,GACzB;IAAE,QAAQ,CAAC,MAAM,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,YAAY,EAAE,SAAS,WAAW,EAAE,CAAA;CAAE,GACxE;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;AAMzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,QAAQ,EAAE,WAAW,GACpB,iBAAiB,CA2CnB"}

package/dist/declaration.js

@@ -0,0 +1,184 @@
+import { describeObjectType, } from '@idfkit/core';
+import { contextAt } from './cursor.js';
+const NOT_APPLICABLE = { status: 'notApplicable' };
+const NO_SCHEMA = { status: 'noSchema' };
+const NONE = { status: 'ok', declarations: [] };
+/**
+ * Where the name under the cursor is declared.
+ *
+ * Two steps, and keeping them apart is what keeps this honest. Which objects declare the name is
+ * resolved against the caller's document, by the two rules the model itself uses and no third one
+ * (FR-029): the object's own name, when its type's `nref` contributes to a list this field points
+ * into, and an ordinary field's value, when that field's `ref` does. Only then is the declaring
+ * statement located in the text, by looking for the name the document holds and confirming with a
+ * cursor context that the match really is that type's declaring field. So the text is never
+ * searched for a string that happens to match: it is searched for a name the document has already
+ * said is declared, and a match that turns out to be a value somewhere else is discarded.
+ *
+ * The document is the caller's, exactly as it is for reference completion, and for the same reason
+ * (research R9): declarations are a whole-document fact, every consumer already holds a document,
+ * and parsing one here would put the eighty milliseconds this design exists to avoid back on the
+ * keystroke path. A document a keystroke behind the text is the correct input rather than a stale
+ * one.
+ *
+ * **Honest bound.** Locating a declaration reads the text rather than one statement of it, because
+ * "every declaration" is a question about the whole file and cannot be answered from a bounded
+ * local scan. The reading is `String.prototype.indexOf`, a native scan of a few hundred kilobytes
+ * costing a small fraction of a millisecond, plus one bounded cursor context per candidate match,
+ * and no layer is built and no document is parsed. It is stated here rather than left for a reader
+ * to discover in a profile.
+ *
+ * `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 declarationAt(text, offset, schema, document) {
+    const context = contextAt(text, offset, schema);
+    // A type name declares nothing and names nothing, a comment holds no values, and between two
+    // statements there is no value to follow. Reporting `'noSchema'` in a comment would send a
+    // caller off to load one that would change this answer not at all.
+    if (context.at !== 'field')
+        return NOT_APPLICABLE;
+    if (schema === undefined)
+        return NO_SCHEMA;
+    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 index = context.fieldIndex;
+    const fieldName = context.fieldName;
+    // No field index on a `'field'` context is unreachable, and a field the type does not define is
+    // ordinary: a statement may carry more fields than its type has.
+    if (index === undefined || fieldName === undefined)
+        return NOT_APPLICABLE;
+    const lists = listsPointedInto(schema, typeName, type, fieldName);
+    // The field points at nothing. Searching the document for an object that happens to be called
+    // whatever is written here would find one often enough to be believed and would be a guess.
+    if (lists.length === 0)
+        return NOT_APPLICABLE;
+    const written = context.statement.fields[index];
+    const target = written === undefined ? '' : text.slice(written.start, written.end);
+    // A field left empty names nothing, which is the same answer as a name nothing declares.
+    if (target === '')
+        return NONE;
+    const declarations = [];
+    const seen = new Set();
+    for (const declared of declaringObjects(document, schema, new Set(lists), fold(target))) {
+        const region = locate(text, schema, declared);
+        if (region === undefined || seen.has(region.start))
+            continue;
+        seen.add(region.start);
+        declarations.push({ region, typeName: declared.typeName });
+    }
+    return { status: 'ok', declarations };
+}
+/**
+ * The reference lists a field points into, taken from `describeObjectType` (FR-029).
+ *
+ * With the one hole `completionsAt` documents at length: `describeObjectType` drops the type's
+ * positional first field, which on an anonymous type is a real field, so that one is read from its
+ * own record. Reading `ol` is the same key the description reports and not a second opinion about
+ * it.
+ */
+function listsPointedInto(schema, typeName, type, fieldName) {
+    const described = describeObjectType(schema, typeName).fields.find((field) => field.name === fieldName);
+    if (described !== undefined)
+        return described.objectList ?? [];
+    return type.p[fieldName]?.ol ?? [];
+}
+/**
+ * The objects declaring `folded` into one of `wanted`.
+ *
+ * The two ways a name reaches a reference list, and no third one (FR-029). Both are read, because
+ * the second is how anonymous types such as `FluidProperties:Name` carry their identity, and
+ * treating those as nameless would report nothing where the model plainly declares something.
+ *
+ * Membership of the lists the field points into is what makes a match a declaration rather than a
+ * coincidence. A `Zone` and a `Construction` may both be called `Office`, and following a
+ * construction name to the zone would be the guess this function exists to avoid. It is why a name
+ * declared only into some other list reports none here while the validator's dangling check, which
+ * asks the coarser question of whether any object declares the name at all, stays quiet: this
+ * reports what the field can name, not what the file happens to contain.
+ *
+ * Names are compared case-insensitively, the way EnergyPlus resolves them and the way every other
+ * name comparison in this library does.
+ */
+function declaringObjects(document, schema, wanted, folded) {
+    const out = [];
+    for (const object of document.objects()) {
+        const canonical = schema.resolve(object.typeName) ?? object.typeName;
+        const type = schema.get(canonical);
+        if (type === undefined)
+            continue;
+        const nameIndex = type.f.indexOf('name');
+        if (nameIndex >= 0 &&
+            object.name !== '' &&
+            fold(object.name) === folded &&
+            contributes(type.nref, wanted)) {
+            out.push({ typeName: canonical, fieldIndex: nameIndex, text: object.name });
+        }
+        for (const [field, definition] of Object.entries(type.p)) {
+            if (!contributes(definition.ref, wanted))
+                continue;
+            const value = object.get(field);
+            if (typeof value !== 'string' || value === '' || fold(value) !== folded)
+                continue;
+            const fieldIndex = type.f.indexOf(field);
+            if (fieldIndex < 0)
+                continue;
+            out.push({ typeName: canonical, fieldIndex, text: value });
+        }
+    }
+    return out;
+}
+/** Whether any list this record contributes to is one the field points into. */
+function contributes(declared, wanted) {
+    if (declared === undefined)
+        return false;
+    return declared.some((list) => wanted.has(list));
+}
+/**
+ * The region in the text where this object writes the name it declares.
+ *
+ * Every occurrence of the name is a candidate and a cursor context decides each one: the match
+ * must be a field, of the declaring type, at the declaring field's index, and the field's whole
+ * text must be the name rather than a value containing it, so `Office` never resolves to
+ * `Office Zone 2`. The first survivor is the answer, because a document cannot hold two objects of
+ * one type sharing a name: `IdfDocument.addRaw` throws on the second and `parseIdf` records a
+ * `ParseError` and skips it, which is the same fact the finding correlation rests on (research
+ * R6).
+ *
+ * The comparison is exact rather than folded because the string being looked for came out of the
+ * document, which stores a value as the text wrote it, trimmed and with comments stripped. The one
+ * case that misses is a name interrupted by a comment between two of its words, which the reader
+ * joins and the syntax layer does not; that declaration is then reported as unlocatable rather
+ * than as a region on the wrong characters.
+ */
+function locate(text, schema, declared) {
+    for (let from = text.indexOf(declared.text); from >= 0; from = text.indexOf(declared.text, from + 1)) {
+        const context = contextAt(text, from, schema);
+        if (context.at !== 'field' || context.fieldIndex !== declared.fieldIndex)
+            continue;
+        if (context.typeName !== declared.typeName)
+            continue;
+        const region = context.statement.fields[declared.fieldIndex];
+        if (region === undefined)
+            continue;
+        if (text.slice(region.start, region.end) !== declared.text)
+            continue;
+        return region;
+    }
+    return undefined;
+}
+/** Case-insensitive name comparison, as EnergyPlus resolves names. */
+function fold(value) {
+    return value.toLowerCase();
+}
+//# sourceMappingURL=declaration.js.map

package/dist/declaration.js.map

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