@idfkit/core 0.2.0-rc.2 → 0.2.0

package/dist/syntax/region.js

@@ -0,0 +1,105 @@
+/**
+ * Line index per source, built once and reused.
+ *
+ * Keyed by the source object rather than by its text, because a `SyntaxLayer` is immutable and
+ * lives as long as the document does, while keying on the string itself would hold megabytes of
+ * text alive for the sake of a few kilobytes of offsets. A caller that passes a fresh object
+ * literal each time gets a fresh index each time, which is the documented cost of doing that.
+ */
+const lineIndexes = new WeakMap();
+/**
+ * Offsets at which each line begins, one entry per line, ascending.
+ *
+ * A line break is a line feed, and nothing else. A carriage return before it belongs to the line
+ * it ends, so a column at the end of a CRLF line is one greater than the same column in a file
+ * using line feeds alone, which is what every editor reports. A lone carriage return is *not* a
+ * break: the existing lexer does not treat it as one and Python's `_line_and_column` counts line
+ * feeds, and the conformance corpus compares a finding on its line, so a third opinion here would
+ * put the two libraries one line apart on a file no gate would explain.
+ *
+ * @internal
+ */
+export function lineStartsOf(source) {
+    const cached = lineIndexes.get(source);
+    if (cached !== undefined)
+        return cached;
+    const starts = buildLineStarts(source.text);
+    lineIndexes.set(source, starts);
+    return starts;
+}
+/**
+ * The line and column an offset falls on.
+ *
+ * Binary search over the line index, so a query costs the logarithm of the line count rather than
+ * a scan of the text. An offset outside `[0, text.length]` is clamped into range rather than
+ * throwing: a cursor arrives from an editor that may be a keystroke ahead of the text this layer
+ * was built from, and refusing to answer is worse than answering about the nearest character.
+ *
+ * The column of a *statement* is the column of its first non-blank character, not of the
+ * whitespace indenting it. This function does not enforce that rule, because a statement's region
+ * already starts at that character; it is stated here because every column this feature reports
+ * obeys it, and because the conformance corpus compares findings on their line and type name and
+ * would notice the number moving.
+ */
+export function lineColumnAt(source, offset) {
+    const clamped = clampOffset(offset, source.text.length);
+    const starts = lineStartsOf(source);
+    const line = lineIndexAt(starts, clamped);
+    return { line: line + 1, column: clamped - starts[line] + 1 };
+}
+/**
+ * The offset a line and column names.
+ *
+ * The inverse of {@link lineColumnAt} for every position that exists, and clamped for every one
+ * that does not: a line past the end resolves on the last line, a column past the end of its line
+ * resolves at the line's last position, which is the offset of the break that ends it. Round
+ * tripping an out-of-range position therefore returns the clamped position rather than the one
+ * asked for, which is the only honest answer available.
+ */
+export function offsetAt(source, position) {
+    const text = source.text;
+    const starts = lineStartsOf(source);
+    const line = clampOffset(position.line - 1, starts.length - 1);
+    const lineStart = starts[line];
+    // One past the last position on this line is where the next line starts, so the last position on
+    // it is one before that: the offset of the line feed, at which a cursor is still on this line.
+    const lineEnd = line + 1 < starts.length ? starts[line + 1] - 1 : text.length;
+    const offset = lineStart + clampOffset(position.column - 1, text.length);
+    return offset > lineEnd ? lineEnd : offset;
+}
+/** Two passes so the array is allocated once at its exact size; `indexOf` does the scanning. */
+function buildLineStarts(text) {
+    let count = 1;
+    for (let at = text.indexOf('\n'); at !== -1; at = text.indexOf('\n', at + 1))
+        count += 1;
+    const starts = new Int32Array(count);
+    let line = 1;
+    for (let at = text.indexOf('\n'); at !== -1; at = text.indexOf('\n', at + 1)) {
+        starts[line] = at + 1;
+        line += 1;
+    }
+    return starts;
+}
+/** Index of the greatest line start that is at or before `offset`. */
+function lineIndexAt(starts, offset) {
+    let low = 0;
+    let high = starts.length - 1;
+    while (low < high) {
+        const middle = (low + high + 1) >> 1;
+        if (starts[middle] <= offset)
+            low = middle;
+        else
+            high = middle - 1;
+    }
+    return low;
+}
+/** 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=region.js.map

package/dist/syntax/region.js.map

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

package/dist/syntax/tokens.d.ts

@@ -0,0 +1,80 @@
+import type { Region } from './region.js';
+/**
+ * What a span of text is, grammatically. Nothing here needs a schema: the layer records what the
+ * text says and never what it means, so a `value` is a value whether or not the field exists.
+ */
+export type TokenKind = 'typeName' | 'value' | 'separator' | 'terminator' | 'comment' | 'trivia';
+/**
+ * One token, materialised.
+ *
+ * A `Token` *is* a `Region` rather than carrying one, which keeps a classified stream to one
+ * object per token instead of two. On a file of forty thousand lines that difference is the
+ * difference between an editor that repaints and one that stutters, and a token still passes
+ * anywhere a region is expected.
+ *
+ * A materialised token never crosses a line boundary; a stored `value` region may, because the
+ * format lets a field be written across two lines, and the classification view splits it.
+ */
+export interface Token extends Region {
+    readonly kind: TokenKind;
+}
+/**
+ * Every token of one text, packed into three parallel arrays.
+ *
+ * Nine bytes per token, against upwards of forty for an object: a start, an end, and a kind code,
+ * held in `Int32Array`, `Int32Array` and `Uint8Array`. On a reference model of ten thousand
+ * statements that is roughly 3.6 MB rather than upwards of 16 MB.
+ *
+ * This is a contract rather than an implementation note. The intended use is an editor holding
+ * several large files open at once, and a layer that allocated an object per token would pass
+ * every correctness test while being unusable there. So `Token` objects are materialised only when
+ * a caller asks for one, which for classification means only for the tokens actually drawn.
+ *
+ * The store knows nothing of the scanner that fills it or of the layer that holds it, and nothing
+ * of the text either: it holds positions, and the text they index stays with the layer.
+ */
+export declare class TokenStore implements Iterable<Token> {
+    #private;
+    constructor(capacity?: number);
+    /** How many tokens are stored. The arrays below are longer than this; they carry slack. */
+    get length(): number;
+    /**
+     * Start offsets, in source order.
+     *
+     * A view over the live buffer, trimmed to `length`, for a consumer that wants to walk the
+     * positions without materialising anything. It is invalidated by the next {@link push}, which in
+     * practice means it is safe for as long as the layer is: nothing appends to a built layer.
+     */
+    get starts(): Int32Array;
+    /** End offsets, exclusive, in source order. A live view, like {@link starts}. */
+    get ends(): Int32Array;
+    /** Kind codes, indices into the `TokenKind` union. A live view, like {@link starts}. */
+    get kinds(): Uint8Array;
+    /** Append one token and return its index. Grows geometrically, so a scan stays linear. */
+    push(start: number, end: number, kind: TokenKind): number;
+    /** The start offset of one token. */
+    startAt(index: number): number;
+    /** The end offset of one token, exclusive. */
+    endAt(index: number): number;
+    /** The kind of one token. */
+    kindAt(index: number): TokenKind;
+    /** The stored kind code of one token, for a consumer encoding kinds numerically. */
+    kindCodeAt(index: number): number;
+    /**
+     * Build a `Token` object for one stored token.
+     *
+     * The only place a token becomes an object. Called for the tokens a consumer actually reads, and
+     * never on the way in.
+     */
+    materialise(index: number): Token;
+    /**
+     * Every stored token, materialised one at a time.
+     *
+     * Convenient rather than cheap: it allocates per token, so a consumer colouring a viewport reads
+     * the arrays or goes through `classify`, which yields only what it is asked for. Note that this
+     * yields stored tokens alone, so the gaps between them are not covered; `trivia` is never stored
+     * and is computed as the complement.
+     */
+    [Symbol.iterator](): IterableIterator<Token>;
+}
+//# sourceMappingURL=tokens.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../../src/syntax/tokens.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C;;;GAGG;AACH,MAAM,MAAM,SAAS,GACjB,UAAU,GACV,OAAO,GACP,WAAW,GACX,YAAY,GACZ,SAAS,GACT,QAAQ,CAAC;AAEb;;;;;;;;;;GAUG;AACH,MAAM,WAAW,KAAM,SAAQ,MAAM;IACnC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;CAC1B;AAwBD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,UAAW,YAAW,QAAQ,CAAC,KAAK,CAAC;;gBAMpC,QAAQ,GAAE,MAAyB;IAO/C,2FAA2F;IAC3F,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;;;;OAMG;IACH,IAAI,MAAM,IAAI,UAAU,CAEvB;IAED,iFAAiF;IACjF,IAAI,IAAI,IAAI,UAAU,CAErB;IAED,wFAAwF;IACxF,IAAI,KAAK,IAAI,UAAU,CAEtB;IAED,0FAA0F;IAC1F,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM;IAUzD,qCAAqC;IACrC,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAI9B,8CAA8C;IAC9C,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAI5B,6BAA6B;IAC7B,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS;IAIhC,oFAAoF;IACpF,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM;IAIjC;;;;;OAKG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK;IASjC;;;;;;;OAOG;IACF,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,KAAK,CAAC;CAuB9C"}

package/dist/syntax/tokens.js

@@ -0,0 +1,140 @@
+/** Kind codes, in the order the union declares them. The index is what `kinds` stores. */
+const KIND_BY_CODE = [
+    'typeName',
+    'value',
+    'separator',
+    'terminator',
+    'comment',
+    'trivia',
+];
+const CODE_BY_KIND = {
+    typeName: 0,
+    value: 1,
+    separator: 2,
+    terminator: 3,
+    comment: 4,
+    trivia: 5,
+};
+/** Where growth starts. Small enough for a one-statement file, large enough to skip early copies. */
+const INITIAL_CAPACITY = 64;
+/**
+ * Every token of one text, packed into three parallel arrays.
+ *
+ * Nine bytes per token, against upwards of forty for an object: a start, an end, and a kind code,
+ * held in `Int32Array`, `Int32Array` and `Uint8Array`. On a reference model of ten thousand
+ * statements that is roughly 3.6 MB rather than upwards of 16 MB.
+ *
+ * This is a contract rather than an implementation note. The intended use is an editor holding
+ * several large files open at once, and a layer that allocated an object per token would pass
+ * every correctness test while being unusable there. So `Token` objects are materialised only when
+ * a caller asks for one, which for classification means only for the tokens actually drawn.
+ *
+ * The store knows nothing of the scanner that fills it or of the layer that holds it, and nothing
+ * of the text either: it holds positions, and the text they index stays with the layer.
+ */
+export class TokenStore {
+    #starts;
+    #ends;
+    #kinds;
+    #length = 0;
+    constructor(capacity = INITIAL_CAPACITY) {
+        const initial = Math.max(0, Math.trunc(capacity));
+        this.#starts = new Int32Array(initial);
+        this.#ends = new Int32Array(initial);
+        this.#kinds = new Uint8Array(initial);
+    }
+    /** How many tokens are stored. The arrays below are longer than this; they carry slack. */
+    get length() {
+        return this.#length;
+    }
+    /**
+     * Start offsets, in source order.
+     *
+     * A view over the live buffer, trimmed to `length`, for a consumer that wants to walk the
+     * positions without materialising anything. It is invalidated by the next {@link push}, which in
+     * practice means it is safe for as long as the layer is: nothing appends to a built layer.
+     */
+    get starts() {
+        return this.#starts.subarray(0, this.#length);
+    }
+    /** End offsets, exclusive, in source order. A live view, like {@link starts}. */
+    get ends() {
+        return this.#ends.subarray(0, this.#length);
+    }
+    /** Kind codes, indices into the `TokenKind` union. A live view, like {@link starts}. */
+    get kinds() {
+        return this.#kinds.subarray(0, this.#length);
+    }
+    /** Append one token and return its index. Grows geometrically, so a scan stays linear. */
+    push(start, end, kind) {
+        const index = this.#length;
+        if (index === this.#starts.length)
+            this.#grow();
+        this.#starts[index] = start;
+        this.#ends[index] = end;
+        this.#kinds[index] = CODE_BY_KIND[kind];
+        this.#length = index + 1;
+        return index;
+    }
+    /** The start offset of one token. */
+    startAt(index) {
+        return this.#starts[this.#checked(index)];
+    }
+    /** The end offset of one token, exclusive. */
+    endAt(index) {
+        return this.#ends[this.#checked(index)];
+    }
+    /** The kind of one token. */
+    kindAt(index) {
+        return KIND_BY_CODE[this.#kinds[this.#checked(index)]];
+    }
+    /** The stored kind code of one token, for a consumer encoding kinds numerically. */
+    kindCodeAt(index) {
+        return this.#kinds[this.#checked(index)];
+    }
+    /**
+     * Build a `Token` object for one stored token.
+     *
+     * The only place a token becomes an object. Called for the tokens a consumer actually reads, and
+     * never on the way in.
+     */
+    materialise(index) {
+        const at = this.#checked(index);
+        return {
+            start: this.#starts[at],
+            end: this.#ends[at],
+            kind: KIND_BY_CODE[this.#kinds[at]],
+        };
+    }
+    /**
+     * Every stored token, materialised one at a time.
+     *
+     * Convenient rather than cheap: it allocates per token, so a consumer colouring a viewport reads
+     * the arrays or goes through `classify`, which yields only what it is asked for. Note that this
+     * yields stored tokens alone, so the gaps between them are not covered; `trivia` is never stored
+     * and is computed as the complement.
+     */
+    *[Symbol.iterator]() {
+        for (let index = 0; index < this.#length; index += 1)
+            yield this.materialise(index);
+    }
+    #checked(index) {
+        if (!Number.isInteger(index) || index < 0 || index >= this.#length) {
+            throw new RangeError(`No token at index ${index} (${this.#length} stored)`);
+        }
+        return index;
+    }
+    #grow() {
+        const capacity = this.#starts.length === 0 ? INITIAL_CAPACITY : this.#starts.length * 2;
+        const starts = new Int32Array(capacity);
+        const ends = new Int32Array(capacity);
+        const kinds = new Uint8Array(capacity);
+        starts.set(this.#starts);
+        ends.set(this.#ends);
+        kinds.set(this.#kinds);
+        this.#starts = starts;
+        this.#ends = ends;
+        this.#kinds = kinds;
+    }
+}
+//# sourceMappingURL=tokens.js.map

package/dist/syntax/tokens.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idfkit/core",
-  "version": "0.2.0-rc.2",
+  "version": "0.2.0",
   "description": "Fast EnergyPlus IDF and epJSON parsing and manipulation for JavaScript",
   "type": "module",
   "license": "MIT",
@@ -43,10 +43,10 @@
   },
   "idfkit": {
     "conformance": "conformance-2026.8",
-    "governance": "governance-2026.10"
+    "governance": "governance-2026.12"
   },
   "dependencies": {
-    "@idfkit/schemas": "0.2.0-rc.2"
+    "@idfkit/schemas": "0.2.0"
   },
   "devDependencies": {
     "@idfkit/types-v26-1": "*",