@citisen/litearea 0.1.0

package/dist/types/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/index.ts"],"names":[],"mappings":"AAMA,YAAY,EACV,SAAS,EACT,UAAU,EACV,iBAAiB,EACjB,aAAa,EACb,gBAAgB,EAChB,iBAAiB,EACjB,UAAU,EACV,eAAe,EACf,UAAU,EACV,OAAO,EACP,YAAY,EACZ,SAAS,EACT,QAAQ,EACR,SAAS,EACT,KAAK,EACL,UAAU,EACV,kBAAkB,EAClB,IAAI,EACJ,WAAW,EACX,SAAS,EACT,KAAK,EACL,SAAS,EACT,QAAQ,EACR,cAAc,EACd,KAAK,EACL,iBAAiB,EACjB,eAAe,EACf,QAAQ,EACR,SAAS,EACT,WAAW,GACZ,MAAM,YAAY,CAAA;AAEnB,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAE/D,OAAO,EACL,KAAK,EACL,cAAc,EACd,YAAY,EACZ,QAAQ,EACR,UAAU,EACV,MAAM,EACN,WAAW,EACX,UAAU,EACV,OAAO,EACP,UAAU,EACV,OAAO,EACP,WAAW,EACX,YAAY,EACZ,UAAU,GACX,MAAM,WAAW,CAAA;AAElB,OAAO,EACL,oBAAoB,EACpB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,KAAK,cAAc,GACpB,MAAM,iBAAiB,CAAA;AAExB,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,IAAI,EACJ,KAAK,eAAe,EACpB,KAAK,UAAU,GAChB,MAAM,WAAW,CAAA;AAElB,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,MAAM,eAAe,CAAA;AAEnG,OAAO,EAAE,OAAO,EAAE,oBAAoB,EAAE,KAAK,UAAU,EAAE,MAAM,cAAc,CAAA;AAE7E,OAAO,EACL,UAAU,EACV,iBAAiB,EACjB,WAAW,EACX,IAAI,EACJ,KAAK,UAAU,EACf,KAAK,MAAM,EACX,KAAK,WAAW,GACjB,MAAM,WAAW,CAAA;AAElB,OAAO,EACL,eAAe,EACf,QAAQ,EACR,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,GACvB,MAAM,eAAe,CAAA;AAEtB,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAE1D,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA"}

package/dist/types/core/inspect.d.ts

@@ -0,0 +1,34 @@
+import type { Decoration, Diagnostic, Grammar, Token } from './types.js';
+import { type ResolvedGrammar } from './scan.js';
+/** Everything one pass over a document produced. */
+export interface Inspection<State = unknown> {
+    /** The text this was computed from, kept so nothing has to guess its version. */
+    text: string;
+    tokens: Token[];
+    /** Lexical problems, the grammar's `checks`, and its `validate`, together. */
+    diagnostics: Diagnostic[];
+    /** Semantic ranges that are not tokens. */
+    decorations: Decoration[];
+    /** Whatever `Grammar.analyze` returned. */
+    state: State;
+}
+/**
+ * Inspect a document: paint, problems, decorations, and structure in one pass.
+ * @param source - the document.
+ * @param grammar - the language, as written or already resolved.
+ * @returns everything the editor needs for one text.
+ */
+export declare function inspect<State>(source: string, grammar: Grammar<State> | ResolvedGrammar<State>): Inspection<State>;
+/**
+ * Sort diagnostics by position and drop duplicates.
+ *
+ * Two rules can legitimately notice the same mistake — a vocabulary's own
+ * rejection and a grammar's validator both know that `nope` is not a colour —
+ * and drawing the underline twice makes it darker rather than more informative.
+ * Duplicates are compared on position, code, and message, so two genuinely
+ * different complaints about one word both survive.
+ * @param diagnostics - the collected diagnostics.
+ * @returns the deduplicated, ordered list.
+ */
+export declare function normalizeDiagnostics(diagnostics: readonly Diagnostic[]): Diagnostic[];
+//# sourceMappingURL=inspect.d.ts.map

package/dist/types/core/inspect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inspect.d.ts","sourceRoot":"","sources":["../../../src/core/inspect.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAEV,UAAU,EAEV,UAAU,EACV,OAAO,EACP,KAAK,EACN,MAAM,YAAY,CAAA;AAEnB,OAAO,EAA2C,KAAK,eAAe,EAAE,MAAM,WAAW,CAAA;AAGzF,oDAAoD;AACpD,MAAM,WAAW,UAAU,CAAC,KAAK,GAAG,OAAO;IACzC,iFAAiF;IACjF,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,8EAA8E;IAC9E,WAAW,EAAE,UAAU,EAAE,CAAA;IACzB,2CAA2C;IAC3C,WAAW,EAAE,UAAU,EAAE,CAAA;IACzB,2CAA2C;IAC3C,KAAK,EAAE,KAAK,CAAA;CACb;AAuED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAC3B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,GAAG,eAAe,CAAC,KAAK,CAAC,GAC/C,UAAU,CAAC,KAAK,CAAC,CAqCnB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,SAAS,UAAU,EAAE,GAAG,UAAU,EAAE,CAUrF"}

package/dist/types/core/rank.d.ts

@@ -0,0 +1,82 @@
+/** A needle and the positions in the label it matched. */
+export interface FuzzyMatch {
+    /** The ranking score. Higher is a better match. */
+    score: number;
+    /** The matched offsets into the label, ascending, for showing what matched. */
+    indices: number[];
+    /** The tier the match reached, for tests and for explaining a ranking. */
+    tier: number;
+}
+/**
+ * Whether a position in a label starts a word.
+ *
+ * Three things start one: the beginning, a separator, and a lower-to-upper
+ * transition. The third is what makes camelCase names searchable by their humps,
+ * and it is why `NotoSans` and `Noto Sans` behave the same way under a needle
+ * like `ns`.
+ * @param label - the text being searched.
+ * @param index - a position in it.
+ * @returns whether a word starts there.
+ */
+export declare function isWordStart(label: string, index: number): boolean;
+/**
+ * Match a needle against a label.
+ *
+ * Case follows the needle: a needle with an uppercase character is matched
+ * case-sensitively, so `Inter` does not quietly match `inter`, while an
+ * all-lowercase needle matches anything. That is the same "smart case" a
+ * terminal has used for decades and the one VSCode applies.
+ * @param needle - what the user has typed.
+ * @param label - what is being searched.
+ * @returns the score and matched offsets, or undefined when the needle does not match.
+ */
+export declare function fuzzyMatch(needle: string, label: string): FuzzyMatch | undefined;
+/** One row of a ranked list, with the evidence for its position. */
+export interface Ranked<T> {
+    item: T;
+    score: number;
+    /** The offsets in the label that matched, for emphasising them in the list. */
+    indices: number[];
+}
+/** How to read a row while ranking it. */
+export interface RankOptions<T> {
+    /** The text shown to the user. */
+    label(item: T): string;
+    /** The text matched against the needle, when it differs from the label. */
+    filterText?(item: T): string;
+    /**
+     * The primary sort key, as VSCode's `sortText` is: rows are ordered by it
+     * first and by match score only within an equal key. It is how a grammar puts
+     * a whole group on top — the value already in effect, say — without pretending
+     * its label starts with a `0`.
+     */
+    sortText?(item: T): string | undefined;
+}
+/**
+ * Filter and order rows for a needle.
+ *
+ * An empty needle keeps every row in the order the grammar declared, which is
+ * what Ctrl+Space should show: the whole vocabulary, grouped the way the grammar
+ * thinks about it, not alphabetised by a scorer that has nothing to go on.
+ * @param items - the candidate rows.
+ * @param needle - what the user has typed.
+ * @param options - how to read a row.
+ * @returns the matching rows, best first.
+ */
+export declare function rank<T>(items: readonly T[], needle: string, options: RankOptions<T>): Ranked<T>[];
+/**
+ * Split a label around the characters a needle matched, for the list to emphasise.
+ *
+ * Returned as segments rather than as a marked-up string because the caller is
+ * building DOM nodes, not HTML: a font family called `<b>` must be shown as
+ * `<b>`, and a completer that returns markup has to escape what it was given or
+ * it is wrong about a real font.
+ * @param label - the row's text.
+ * @param indices - the matched offsets, ascending.
+ * @returns alternating plain and matched segments, in order.
+ */
+export declare function highlightSegments(label: string, indices: readonly number[]): Array<{
+    text: string;
+    matched: boolean;
+}>;
+//# sourceMappingURL=rank.d.ts.map

package/dist/types/core/rank.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rank.d.ts","sourceRoot":"","sources":["../../../src/core/rank.ts"],"names":[],"mappings":"AAuDA,0DAA0D;AAC1D,MAAM,WAAW,UAAU;IACzB,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAA;IACb,+EAA+E;IAC/E,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,0EAA0E;IAC1E,IAAI,EAAE,MAAM,CAAA;CACb;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAMjE;AAkCD;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAqEhF;AA0BD,oEAAoE;AACpE,MAAM,WAAW,MAAM,CAAC,CAAC;IACvB,IAAI,EAAE,CAAC,CAAA;IACP,KAAK,EAAE,MAAM,CAAA;IACb,+EAA+E;IAC/E,OAAO,EAAE,MAAM,EAAE,CAAA;CAClB;AAED,0CAA0C;AAC1C,MAAM,WAAW,WAAW,CAAC,CAAC;IAC5B,kCAAkC;IAClC,KAAK,CAAC,IAAI,EAAE,CAAC,GAAG,MAAM,CAAA;IACtB,2EAA2E;IAC3E,UAAU,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,MAAM,CAAA;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC,GAAG,MAAM,GAAG,SAAS,CAAA;CACvC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,EAAE,CA6BjG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,SAAS,MAAM,EAAE,GACzB,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,CAe3C"}

package/dist/types/core/scan.d.ts

@@ -0,0 +1,51 @@
+import type { Diagnostic, Grammar, Rule, Scope, Token } from './types.js';
+/** A grammar with its defaults filled in and its patterns made safe to reuse. */
+export interface ResolvedGrammar<State = unknown> {
+    /**
+     * Marks this value as already resolved.
+     *
+     * Present so the two shapes can be told apart without guessing. The obvious test
+     * — "does it have a `fallbackScope`?" — is wrong, because a plain grammar is
+     * allowed to declare one, and the mistake surfaces as the engine reading `.grammar`
+     * off a value that has no such field and crashing at the first keystroke.
+     */
+    readonly __resolved: true;
+    grammar: Grammar<State>;
+    rules: readonly Rule<State>[];
+    /** The scope a character no rule claimed is painted with. */
+    fallbackScope: Scope;
+    /** The single-character test that decides where words begin and end. */
+    wordChars: RegExp;
+}
+/**
+ * Whether a value is a resolved grammar rather than one as written.
+ * @param value - the grammar, either shape.
+ * @returns whether it is already resolved.
+ */
+export declare function isResolvedGrammar<State>(value: Grammar<State> | ResolvedGrammar<State>): value is ResolvedGrammar<State>;
+/** The whole result of one scan: the paint, what the scan noticed, and the analysis. */
+export interface ScanResult<State = unknown> {
+    tokens: Token[];
+    /**
+     * What the lexical pass itself found: a word a vocabulary rejected, a region
+     * that never closed. A grammar's own `checks` and `validate` are added by
+     * `diagnose`, which builds on this.
+     */
+    diagnostics: Diagnostic[];
+    /** Whatever `Grammar.analyze` returned, or `initialState`. */
+    state: State;
+}
+/**
+ * Fill in a grammar's defaults and make its patterns safe.
+ * @param grammar - the grammar as written.
+ * @returns the grammar the scanner runs.
+ */
+export declare function resolveGrammar<State>(grammar: Grammar<State>): ResolvedGrammar<State>;
+/**
+ * Scan a document into tokens.
+ * @param source - the document.
+ * @param grammar - the language, as written or already resolved.
+ * @returns the tokens, the lexical diagnostics, and the analysis.
+ */
+export declare function scan<State>(source: string, grammar: Grammar<State> | ResolvedGrammar<State>): ScanResult<State>;
+//# sourceMappingURL=scan.d.ts.map

package/dist/types/core/scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../../src/core/scan.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EACV,UAAU,EACV,OAAO,EAGP,IAAI,EAGJ,KAAK,EAEL,KAAK,EAIN,MAAM,YAAY,CAAA;AAKnB,iFAAiF;AACjF,MAAM,WAAW,eAAe,CAAC,KAAK,GAAG,OAAO;IAC9C;;;;;;;OAOG;IACH,QAAQ,CAAC,UAAU,EAAE,IAAI,CAAA;IACzB,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,CAAA;IACvB,KAAK,EAAE,SAAS,IAAI,CAAC,KAAK,CAAC,EAAE,CAAA;IAC7B,6DAA6D;IAC7D,aAAa,EAAE,KAAK,CAAA;IACpB,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAA;CAClB;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EACrC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,GAAG,eAAe,CAAC,KAAK,CAAC,GAC7C,KAAK,IAAI,eAAe,CAAC,KAAK,CAAC,CAEjC;AAED,wFAAwF;AACxF,MAAM,WAAW,UAAU,CAAC,KAAK,GAAG,OAAO;IACzC,MAAM,EAAE,KAAK,EAAE,CAAA;IACf;;;;OAIG;IACH,WAAW,EAAE,UAAU,EAAE,CAAA;IACzB,8DAA8D;IAC9D,KAAK,EAAE,KAAK,CAAA;CACb;AAoDD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,GAAG,eAAe,CAAC,KAAK,CAAC,CAQrF;AAeD;;;;;GAKG;AACH,wBAAgB,IAAI,CAAC,KAAK,EACxB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,GAAG,eAAe,CAAC,KAAK,CAAC,GAC/C,UAAU,CAAC,KAAK,CAAC,CA0gBnB"}

package/dist/types/core/segments.d.ts

@@ -0,0 +1,44 @@
+import type { Decoration, Diagnostic, Severity, Token } from './types.js';
+/** One run of characters that all share the same presentation. */
+export interface PaintSegment {
+    from: number;
+    to: number;
+    /** The characters themselves, so the painter never re-slices. */
+    text: string;
+    /** The scope that colours them. */
+    scope: string;
+    /** The decoration kinds that mark them, in declaration order. */
+    decorations: string[];
+    /** The loudest diagnostic covering them, when one does. */
+    severity: Severity | undefined;
+    /** A hover title donated by a decoration, when it has one. */
+    title: string | undefined;
+}
+/** What a segment builder needs: the three range lists and nothing else. */
+export interface SegmentInput {
+    tokens: readonly Token[];
+    decorations: readonly Decoration[];
+    diagnostics: readonly Diagnostic[];
+}
+/**
+ * Merge a scope, a decoration, and a diagnostic into adjacent segments.
+ *
+ * @param text - the document the ranges refer to.
+ * @param input - the three range lists.
+ * @param fallbackScope - the scope for characters no token covers.
+ * @returns the segments, in order, covering the whole document.
+ */
+export declare function buildSegments(text: string, input: SegmentInput, fallbackScope?: string): PaintSegment[];
+/**
+ * The class attribute for a segment.
+ *
+ * Order matters for a stylesheet author's sanity rather than for the cascade: the
+ * scope comes first so a rule can target `scope + mark` if it ever needs to.
+ * @param segment - the segment.
+ * @param scopeClass - how a scope becomes a class.
+ * @param decorationClass - how a decoration kind becomes a class.
+ * @param severityClass - how a severity becomes a class.
+ * @returns the class list.
+ */
+export declare function segmentClasses(segment: PaintSegment, scopeClass: (scope: string) => string, decorationClass: (kind: string) => string, severityClass: (severity: string) => string): string[];
+//# sourceMappingURL=segments.d.ts.map

package/dist/types/core/segments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"segments.d.ts","sourceRoot":"","sources":["../../../src/core/segments.ts"],"names":[],"mappings":"AAoBA,OAAO,KAAK,EAAE,UAAU,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAEzE,kEAAkE;AAClE,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;IACV,iEAAiE;IACjE,IAAI,EAAE,MAAM,CAAA;IACZ,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAA;IACb,iEAAiE;IACjE,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,2DAA2D;IAC3D,QAAQ,EAAE,QAAQ,GAAG,SAAS,CAAA;IAC9B,8DAA8D;IAC9D,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;CAC1B;AAED,4EAA4E;AAC5E,MAAM,WAAW,YAAY;IAC3B,MAAM,EAAE,SAAS,KAAK,EAAE,CAAA;IACxB,WAAW,EAAE,SAAS,UAAU,EAAE,CAAA;IAClC,WAAW,EAAE,SAAS,UAAU,EAAE,CAAA;CACnC;AAWD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,YAAY,EACnB,aAAa,SAAS,GACrB,YAAY,EAAE,CAoDhB;AA6CD;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,YAAY,EACrB,UAAU,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,EACrC,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EACzC,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,GAC1C,MAAM,EAAE,CAKV"}

package/dist/types/core/text.d.ts

@@ -0,0 +1,113 @@
+import type { LineInfo, Range, Token, WordInfo } from './types.js';
+/** Keeps a number inside a range, which every caller here needs and none should repeat. */
+export declare function clamp(value: number, low: number, high: number): number;
+/** Whether a value is a usable offset: a finite, non-negative integer. */
+export declare function isOffset(value: unknown): value is number;
+/**
+ * The offset each line starts at, in order. The first entry is always `0`.
+ *
+ * `\r\n`, `\n`, and a lone `\r` all end a line, because this text is typed by
+ * hand into a textarea and a paste from a Windows editor must not read as one
+ * long line. The terminator itself belongs to no line: a line's text excludes it
+ * so that column arithmetic never has to reason about a stray carriage return.
+ * @param source - the document.
+ * @returns one offset per line, ascending.
+ */
+export declare function lineStarts(source: string): number[];
+/**
+ * The index of the line an offset falls on.
+ * @param starts - the result of {@link lineStarts}.
+ * @param offset - a character offset.
+ * @returns a zero-based line index.
+ */
+export declare function lineIndexAt(starts: readonly number[], offset: number): number;
+/**
+ * The line an offset falls on, with the offset expressed inside it.
+ *
+ * `before` and `after` are the line's own text split at the caret, which is what
+ * completion and the indentation rules actually want; handing them out here
+ * means neither has to re-derive the split and get it subtly different.
+ * @param source - the document.
+ * @param offset - a character offset; clamped into the document.
+ * @param starts - the result of {@link lineStarts}, when the caller already has it.
+ * @returns the line, its bounds, and the caret's place in it.
+ */
+export declare function lineAt(source: string, offset: number, starts?: readonly number[]): LineInfo;
+/**
+ * Whether a character is part of a word.
+ *
+ * The predicate is supplied by the grammar because it decides three things at
+ * once — what a completion replaces, what a diagnostic underlines, and where a
+ * double click puts the selection — and a language whose names contain a hyphen
+ * must say so or every completion will replace one segment of a name instead of
+ * the name.
+ * @param char - one character, or the empty string at the end of the document.
+ * @param wordChars - a single-character test.
+ * @returns whether the character continues a word.
+ */
+export declare function isWordChar(char: string, wordChars: RegExp): boolean;
+/**
+ * The word at an offset.
+ *
+ * The word is found by expanding in BOTH directions from the offset rather than
+ * by requiring the offset to be strictly inside a word. Completion needs the
+ * second reading: a caret sitting at `Geist|` is at the end of the word, and the
+ * word it is completing is still `Geist` — a lookup that insisted the offset be
+ * interior would find nothing at exactly the moment the user wants a list.
+ * @param source - the document.
+ * @param offset - a character offset; clamped into the document.
+ * @param wordChars - a single-character test.
+ * @returns the word, its range, and the text either side of the caret.
+ */
+export declare function wordInfoAt(source: string, offset: number, wordChars: RegExp): WordInfo;
+/** Whether a range is empty. */
+export declare function isEmptyRange(range: Range): boolean;
+/** Whether an offset lies inside a range, with `to` exclusive. */
+export declare function containsOffset(range: Range, offset: number): boolean;
+/**
+ * The token covering an offset.
+ *
+ * Zero-length tokens are skipped, so a caret at a boundary resolves to the token
+ * it is *inside* rather than to an empty marker sitting on the seam.
+ * @param tokens - the scanned tokens, ascending.
+ * @param offset - a character offset.
+ * @returns the covering token, or undefined in whitespace.
+ */
+export declare function tokenAt(tokens: readonly Token[], offset: number): Token | undefined;
+/**
+ * The scope painted at an offset, when there is one.
+ * @param tokens - the scanned tokens, ascending.
+ * @param offset - a character offset.
+ * @returns the scope, or undefined in whitespace.
+ */
+export declare function scopeAt(tokens: readonly Token[], offset: number): string | undefined;
+/**
+ * The nearest token that ends at or before an offset, skipping whitespace.
+ *
+ * Whitespace is skipped because every caller is asking a question about
+ * structure — "which slot is this word in?" — and a space is never an answer.
+ * @param tokens - the scanned tokens, ascending.
+ * @param offset - a character offset.
+ * @returns the token, or undefined at the start of the document.
+ */
+export declare function tokenBefore(tokens: readonly Token[], offset: number): Token | undefined;
+/**
+ * The nearest token that starts at or after an offset, skipping whitespace.
+ * @param tokens - the scanned tokens, ascending.
+ * @param offset - a character offset.
+ * @returns the token, or undefined at the end of the document.
+ */
+export declare function tokenAfter(tokens: readonly Token[], offset: number): Token | undefined;
+/**
+ * The non-whitespace tokens on one line, in order.
+ *
+ * Completion and diagnostics both ask "what is on this line so far", and both
+ * must ignore the indentation and the gaps between words. Returning the tokens
+ * rather than the words means a grammar can ask what they *were* (their scopes)
+ * and not only what they said.
+ * @param tokens - the scanned tokens, ascending.
+ * @param line - a line number, or a line record.
+ * @returns the tokens on that line.
+ */
+export declare function tokensOnLine(tokens: readonly Token[], line: number | LineInfo): Token[];
+//# sourceMappingURL=text.d.ts.map

package/dist/types/core/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../src/core/text.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AAElE,2FAA2F;AAC3F,wBAAgB,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED,0EAA0E;AAC1E,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,MAAM,CAExD;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAYnD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAS7E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,QAAQ,CAyB3F;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAEnE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,QAAQ,CAetF;AAED,gCAAgC;AAChC,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAElD;AAED,kEAAkE;AAClE,wBAAgB,cAAc,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAEpE;AAID;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAMnF;AAED;;;;;GAKG;AACH,wBAAgB,OAAO,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEpF;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAOvF;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,SAAS,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAMtF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,SAAS,KAAK,EAAE,EACxB,IAAI,EAAE,MAAM,GAAG,QAAQ,GACtB,KAAK,EAAE,CAGT"}