1
import * as lsp from 'vscode-languageserver-protocol';
2
import { Token } from '../parser.js';
3
import { rangeContains } from '../types/range.js';
4
import { ITextDocument } from '../types/textDocument.js';
5

6
const inlineCodePattern = /(?<!`)(`+)((?:.+?|.*?(?:(?:\r?\n).+?)*?)(?:\r?\n)?\1)(?!`)/gm;
7

8
class InlineRanges {
9

10
  public static create() {
11
    return new InlineRanges();
12
  }
13

14
  readonly #map: Map</* line number */ number, lsp.Range[]>;
15

16
  private constructor(data?: ReadonlyMap<number, lsp.Range[]>) {
17
    this.#map = new Map(data);
18
  }
19

20
  public get(line: number): lsp.Range[] {
21
    return this.#map.get(line) || [];
22
  }
23

24
  public add(range: lsp.Range): void {
25
    // Register the range for all lines that it covers
26
    for (let line = range.start.line; line <= range.end.line; line++) {
27
      let ranges = this.#map.get(line);
28
      if (!ranges) {
29
        ranges = [];
30
        this.#map.set(line, ranges);
31
      }
32
      ranges.push(range);
33
    }
34
  }
35

36
  public concat(newRanges: Iterable<lsp.Range>): InlineRanges {
37
    const result = new InlineRanges(this.#map);
38
    for (const range of newRanges) {
39
      result.add(range);
40
    }
41
    return result;
42
  }
43
}
44

45
export class NoLinkRanges {
46
  public static compute(tokens: readonly Token[], document: ITextDocument): NoLinkRanges {
47
    const multiline = tokens
48
      .filter(t => (t.type === 'code_block' || t.type === 'fence' || t.type === 'html_block') && !!t.map)
49
      .map(t => ({ type: t.type, range: t.map as [number, number] }));
50

51
    const inlineRanges = InlineRanges.create();
52
    const text = document.getText();
53
    for (const match of text.matchAll(inlineCodePattern)) {
54
      const startOffset = match.index ?? 0;
55
      const startPosition = document.positionAt(startOffset);
56
      inlineRanges.add(lsp.Range.create(startPosition, document.positionAt(startOffset + match[0].length)));
57
    }
58

59
    return new NoLinkRanges(multiline, inlineRanges);
60
  }
61

62
  private constructor(
63
    /**
64
     * Block element ranges, such as code blocks. Represented by [line_start, line_end).
65
     */
66
    public readonly multiline: ReadonlyArray<{ type: string, range: [number, number] }>,
67

68
    /**
69
     * Inline code spans where links should not be detected
70
     */
71
    public readonly inline: InlineRanges,
72
  ) { }
73

74
  contains(position: lsp.Position, excludeType = ''): boolean {
75
    return this.multiline.some(({ type, range }) => type !== excludeType && position.line >= range[0] && position.line < range[1]) ||
76
      !!this.inline.get(position.line)?.some(inlineRange => rangeContains(inlineRange, position));
77
  }
78

79
  concatInline(inlineRanges: Iterable<lsp.Range>): NoLinkRanges {
80
    return new NoLinkRanges(this.multiline, this.inline.concat(inlineRanges));
81
  }
82
}