@idfkit/core 0.2.0-rc.1 → 0.2.0

package/dist/syntax/layer.d.ts

@@ -0,0 +1,67 @@
+import type { Region } from './region.js';
+import { TokenStore } from './tokens.js';
+/**
+ * One statement as the text writes it, terminated or not.
+ *
+ * Not an object in the model and carrying no schema meaning (FR-006): a statement whose type the
+ * schema never heard of, or which carries twice the fields its type defines, is still a statement.
+ * Deciding what any of it means is the reader's job, and the layer is what a reader positions
+ * against.
+ */
+export interface Statement {
+    /** The whole statement, from its first non-blank character through its terminator. */
+    readonly region: Region;
+    /** Just the type name. Empty, at the offset one would have begun, when none was written. */
+    readonly typeName: Region;
+    /** Type name text, exactly as written and not case-folded. */
+    readonly typeNameText: string;
+    /**
+     * Fields after the type name, in positional order, one region each.
+     *
+     * Index 0 is the first field after the type name, matching `RawObject.values`, which has already
+     * had the type name shifted off. A field written empty still gets a region, an empty one
+     * positioned where its value would have begun, so that positional indexing never shifts and a
+     * blank slot in the middle of an extensible group can still be pointed at.
+     *
+     * The count is what was written rather than what the type defines. A statement carrying more or
+     * fewer fields than its type is a finding, not a representation problem.
+     */
+    readonly fields: readonly Region[];
+    /** True when no terminator was found, meaning the statement runs to end of input. */
+    readonly unterminated: boolean;
+}
+/**
+ * Everything the text contains and where it was.
+ *
+ * The layer holds the text it was built from, which is what makes byte-identical reconstruction a
+ * consequence rather than a feature: a reconstruction defined as concatenating slices of that text
+ * returns the text by construction. What can actually break is the tiling, so that is what the
+ * corpus test asserts and what {@link classify} makes observable.
+ *
+ * Nothing builds a layer implicitly (FR-005). `lex` and `parseIdf` read the same characters
+ * through the same scan and construct none of this, so a caller who never names `scanIdf` pays
+ * neither its time nor its memory.
+ */
+export interface SyntaxLayer {
+    /** The text this layer was built from. Held so regions can be resolved. */
+    readonly text: string;
+    /** Statements in source order. */
+    readonly statements: readonly Statement[];
+    /** Every meaningful token in source order, packed. Whitespace is not among them. */
+    readonly tokens: TokenStore;
+}
+/**
+ * Scan IDF text into a syntax layer.
+ *
+ * Text and nothing else: no schema, because the layer records what the text says and never what it
+ * means (FR-006). It never throws, for any input, and text that violates the grammar is
+ * represented rather than stopped at (FR-004): an unterminated final statement runs to end of
+ * input and says so, a statement written without a type name still tiles, and empty text produces
+ * a layer with no statements and no tokens, which satisfies the tiling invariant vacuously.
+ *
+ * One linear pass over the shared scan, which is the same pass `lex` makes. The budget is a
+ * quarter over a plain read of the same text; the work above the scan is a push per token and a
+ * record per statement.
+ */
+export declare function scanIdf(text: string): SyntaxLayer;
+//# sourceMappingURL=layer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"layer.d.ts","sourceRoot":"","sources":["../../src/syntax/layer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,UAAU,EAAkB,MAAM,aAAa,CAAC;AAEzD;;;;;;;GAOG;AACH,MAAM,WAAW,SAAS;IACxB,sFAAsF;IACtF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,4FAA4F;IAC5F,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,8DAA8D;IAC9D,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,qFAAqF;IACrF,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;CAChC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,WAAW;IAC1B,2EAA2E;IAC3E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,kCAAkC;IAClC,QAAQ,CAAC,UAAU,EAAE,SAAS,SAAS,EAAE,CAAC;IAC1C,oFAAoF;IACpF,QAAQ,CAAC,MAAM,EAAE,UAAU,CAAC;CAC7B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAiHjD"}

package/dist/syntax/layer.js

@@ -0,0 +1,134 @@
+import { scan } from '../parse/scan.js';
+import { TokenStore } from './tokens.js';
+/**
+ * Scan IDF text into a syntax layer.
+ *
+ * Text and nothing else: no schema, because the layer records what the text says and never what it
+ * means (FR-006). It never throws, for any input, and text that violates the grammar is
+ * represented rather than stopped at (FR-004): an unterminated final statement runs to end of
+ * input and says so, a statement written without a type name still tiles, and empty text produces
+ * a layer with no statements and no tokens, which satisfies the tiling invariant vacuously.
+ *
+ * One linear pass over the shared scan, which is the same pass `lex` makes. The budget is a
+ * quarter over a plain read of the same text; the work above the scan is a push per token and a
+ * record per statement.
+ */
+export function scanIdf(text) {
+    const tokens = new TokenStore(initialCapacity(text.length));
+    const statements = [];
+    /**
+     * Comments seen since the last field closed, as flat `[start, end]` pairs in source order.
+     *
+     * They are buffered rather than pushed on sight because a comment can interrupt a field, in
+     * which case the scan reports it before the field it sits inside: the field's own bounds are
+     * only known once the field closes. Emitting them at that point, ordered against the value,
+     * is what keeps the store in source order.
+     */
+    const comments = [];
+    /** Index into {@link comments} of the first pair not yet pushed. */
+    let nextComment = 0;
+    /** Raw text runs of the field being read, as flat `[start, end]` pairs in source order. */
+    const runs = [];
+    /** Offset the current statement opened at. */
+    let openedAt = 0;
+    /** The current statement's type name, replaced when its field closes. */
+    let typeName = EMPTY_REGION;
+    /** The current statement's fields. Reassigned per statement, so a pushed record keeps its own. */
+    let fields = [];
+    /** Push every buffered comment that begins before `offset`, keeping the store in source order. */
+    const flushComments = (offset) => {
+        while (nextComment < comments.length && comments[nextComment] < offset) {
+            tokens.push(comments[nextComment], comments[nextComment + 1], 'comment');
+            nextComment += 2;
+        }
+    };
+    scan(text, {
+        statementStart(offset) {
+            openedAt = offset;
+            fields = [];
+        },
+        /**
+         * The runs are recorded only for the sake of a field written on both sides of a comment that
+         * interrupts it. Every other reader of this scan wants the field's value, which arrives whole
+         * below.
+         */
+        fieldText(start, end) {
+            runs.push(start, end);
+        },
+        fieldEnd(index, start, end) {
+            const region = { start, end };
+            if (index === 0)
+                typeName = region;
+            else
+                fields.push(region);
+            const kind = index === 0 ? 'typeName' : 'value';
+            flushComments(start);
+            // A field written empty has an empty region, which is a position rather than a span, so it
+            // is recorded above and is no token.
+            if (end > start)
+                tokens.push(start, end, kind);
+            // Only a comment can separate two runs of one field, so a run beginning at or after the
+            // value ends is text written after an interrupting comment: `A !- why\n B,` writes both `A`
+            // and `B` into one field. The scan bounds the value at `A` deliberately, so that a value
+            // region and a comment region can never overlap, which leaves `B` reached by no region at
+            // all, and a gap holding something other than whitespace is what the tiling invariant
+            // forbids. Every other run holds the value itself or the whitespace before it, and both
+            // begin before it ends, so a well-formed field never enters the body and never allocates.
+            for (let at = 0; at < runs.length; at += 2) {
+                const runStart = runs[at];
+                if (runStart < end)
+                    continue;
+                const runEnd = runs[at + 1];
+                const raw = text.slice(runStart, runEnd);
+                const from = runStart + (raw.length - raw.trimStart().length);
+                const to = runEnd - (raw.length - raw.trimEnd().length);
+                if (from >= to)
+                    continue;
+                flushComments(from);
+                tokens.push(from, to, kind);
+            }
+            flushComments(Infinity);
+            comments.length = 0;
+            nextComment = 0;
+            runs.length = 0;
+        },
+        separator(offset) {
+            tokens.push(offset, offset + 1, 'separator');
+        },
+        terminator(offset) {
+            tokens.push(offset, offset + 1, 'terminator');
+        },
+        comment(start, end) {
+            comments.push(start, end);
+        },
+        statementEnd(end, unterminated) {
+            statements.push({
+                region: { start: openedAt, end },
+                typeName,
+                typeNameText: text.slice(typeName.start, typeName.end),
+                fields,
+                unterminated,
+            });
+        },
+    });
+    // Comments after the last terminator close no field, so nothing has flushed them. Text that is
+    // only comments reaches here having reported no statement at all.
+    flushComments(Infinity);
+    return { text, statements, tokens };
+}
+/**
+ * Stands in until a statement's first field closes, which it always does before the statement
+ * ends, so no statement is ever recorded holding this.
+ */
+const EMPTY_REGION = { start: 0, end: 0 };
+/**
+ * A starting size for the token store, so a large file does not grow it a dozen times.
+ *
+ * A commented IDF line runs to about a dozen characters per token, so one per sixteen undershoots
+ * slightly and costs at most one doubling, which is the safer side to be wrong on: a file that is
+ * mostly whitespace or mostly comment would otherwise pay for capacity it never fills.
+ */
+function initialCapacity(length) {
+    return length < 1024 ? 64 : length >> 4;
+}
+//# sourceMappingURL=layer.js.map

package/dist/syntax/layer.js.map

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

package/dist/syntax/region.d.ts

@@ -0,0 +1,73 @@
+/**
+ * A span of source text, half-open.
+ *
+ * `end` is one past the last character, so `text.slice(start, end)` is exactly the text the
+ * region selects, an empty region is `start === end`, and two adjacent regions share a number
+ * rather than straddling one. An empty region is what a cursor between two characters is.
+ *
+ * Offsets are indices into the JavaScript string, which are UTF-16 code units. Nothing converts
+ * them, because no consumer wants them converted: the Language Server Protocol's default
+ * `positionEncoding` is UTF-16, Monaco measures columns in UTF-16 code units, and CodeMirror
+ * addresses its document by the same offsets. The Python library counts code points instead,
+ * because Python string indices are code points; the two agree for every character below the
+ * astral planes and differ for anything above them, which in practice means an emoji in a
+ * comment. That divergence is registered rather than papered over.
+ */
+export interface Region {
+    /** Offset of the first character, into the source string. */
+    readonly start: number;
+    /** Offset one past the last character. */
+    readonly end: number;
+}
+/**
+ * A position as a human reads it, derived from an offset rather than stored.
+ *
+ * Storing line and column on every region would double its size to hold two numbers that are a
+ * function of one. Both count from one, which is what the existing findings already report; a
+ * consumer whose own convention counts a column from zero subtracts one, and that subtraction is
+ * the consumer's, because a service that guessed which convention its caller wanted would be
+ * modelling a protocol.
+ */
+export interface LineColumn {
+    /** 1-based, counting from the start of the text. */
+    readonly line: number;
+    /** 1-based, in UTF-16 code units, from the start of the line. */
+    readonly column: number;
+}
+/**
+ * The minimum a position query needs: the text its offsets index into.
+ *
+ * Declared structurally rather than by importing `SyntaxLayer`, so that positions stay usable
+ * without one and this module depends on nothing. A `SyntaxLayer` holds its text and therefore
+ * satisfies this, which is what lets `lineColumnAt(layer, offset)` read as the contract writes it.
+ */
+export interface TextSource {
+    /** The text offsets are measured into. */
+    readonly text: string;
+}
+/**
+ * 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 declare function lineColumnAt(source: TextSource, offset: number): LineColumn;
+/**
+ * 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 declare function offsetAt(source: TextSource, position: LineColumn): number;
+//# sourceMappingURL=region.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"region.d.ts","sourceRoot":"","sources":["../../src/syntax/region.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,MAAM;IACrB,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,0CAA0C;IAC1C,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,UAAU;IACzB,oDAAoD;IACpD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,iEAAiE;IACjE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,UAAU;IACzB,0CAA0C;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAgCD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,GAAG,UAAU,CAK3E;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU,GAAG,MAAM,CAUzE"}

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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"}