tricu

syntax.ts (6290B)

---

 // Lexical highlighting and declaration-site decoration. Editor offsets count
 // UTF-16 code units; compiler positions count Unicode scalars.
 export interface Token { start: number; end: number; kind: string; text: string }
 const keywords = new Set(['let', 'in', 'where', 'do', 'case', 'of', 'rec']);
 export function tokenize(source: string): Token[] {
   // Decoration must remain cheap even for large read-only library sources.
   if (source.length > 32_768) return [{ start: 0, end: source.length, kind: '', text: source }];
   const tokens: Token[] = [];
   const add = (start: number, end: number, kind: string): void => { tokens.push({ start, end, kind, text: source.slice(start, end) }); };
   let i = 0;
   while (i < source.length) {
     const start = i, tail = source.slice(i);
     if (tail.startsWith('--')) { const end = source.indexOf('\n', i); i = end < 0 ? source.length : end; add(start, i, 'comment'); }
     else if (tail.startsWith('|-')) { const end = source.indexOf('-|', i + 2); i = end < 0 ? source.length : end + 2; add(start, i, 'comment'); }
     else if (source[i] === '"') {
       i++; let part = start;
       while (i < source.length) {
         if (source[i] === '\\') {
           add(part, i, 'string'); const escape = i; i = Math.min(i + 1 + ((source.codePointAt(i + 1) ?? 0) > 0xffff ? 2 : 1), source.length);
           add(escape, i, /^[\\][ntrfb\\"']$/.test(source.slice(escape, i)) ? 'escape' : 'invalid'); part = i;
         } else if (source[i++] === '"') break;
       }
       if (part < i) add(part, i, 'string');
     } else {
       const match = /^(\s+|![A-Za-z]+|[A-Za-z_][A-Za-z0-9_?'$%.\-]*|[0-9]+|=@|<-|<\||\|>|.)/su.exec(tail)!;
       const text = match[0]; i += text.length;
       const kind = /^\s/.test(text) ? '' : text === 't' ? 'tree' : keywords.has(text) ? 'keyword'
         : ['!import', '!export'].includes(text) ? 'directive' : /^[0-9]/.test(text) ? 'number'
         : /^[A-Za-z_]/.test(text) ? 'name' : /^[()[\]{}]$/.test(text) ? 'bracket' : 'operator';
       add(start, i, kind);
     }
   }
   // Conservative declaration-site recognition, not semantic highlighting.
   // Layout contexts distinguish local equation heads from case-arm captures.
   const significant = tokens.filter(t => t.kind && t.kind !== 'comment');
   const contexts: { kind: string; indent: number; depth: number }[] = [];
   let depth = 0, previous: Token | undefined, directiveLine = -1, line = 0;
   let lineEnd = source.indexOf('\n'); if (lineEnd < 0) lineEnd = source.length;
   let indent = /^ */.exec(source)![0].length;
   for (let n = 0; n < significant.length; n++) {
     const token = significant[n]!;
     while (lineEnd < token.start) {
       line = lineEnd + 1; const next = source.indexOf('\n', line); lineEnd = next < 0 ? source.length : next;
       indent = /^ */.exec(source.slice(line))![0].length;
     }
     const first = token.start === line + indent;
     if (first) while (contexts.length && indent <= contexts.at(-1)!.indent) contexts.pop();
     if (/^[)\]}]$/.test(token.text)) depth--;
     while (contexts.length && depth < contexts.at(-1)!.depth) contexts.pop();
     if (token.kind === 'directive') directiveLine = line;
     if (directiveLine === line && ['as', 'from'].includes(token.text)) token.kind = 'keyword';
     if (token.kind === 'name' && ['@', '=@'].includes(previous?.text ?? '')) token.kind = 'contract';
     const localHead = previous && ['let', 'where', 'rec'].includes(previous.text);
     if (token.kind === 'name' && directiveLine !== line && (localHead || first && (indent === 0 || ['let', 'where'].includes(contexts.at(-1)?.kind ?? '')))) {
       let nesting = 0;
       for (let j = n + 1; j < significant.length; j++) {
         const next = significant[j]!;
         if (next.start > lineEnd || keywords.has(next.text)) break;
         if (nesting === 0 && (next.text === '=' || next.text === '=@')) { token.kind = 'definition'; break; }
         if (/^[([{]$/.test(next.text)) nesting++;
         if (/^[)\]}]$/.test(next.text) && --nesting < 0) break;
         if (!nesting && [':', '<-'].includes(next.text)) break;
       }
     }
     if (['let', 'where', 'of'].includes(token.text)) contexts.push({ kind: token.text, indent, depth });
     if (token.text === 'in') { const index = contexts.map(c => c.kind).lastIndexOf('let'); if (index >= 0) contexts.splice(index); }
     if (/^[([{]$/.test(token.text)) depth++;
     previous = token;
   }
   return tokens;
 }
 
 export function bracketPair(tokens: Token[], caret: number): number[] {
   const brackets = tokens.filter(t => t.kind === 'bracket');
   const selected = brackets.find(t => t.start === caret) ?? brackets.find(t => t.end === caret);
   if (!selected) return [];
   const stack: Token[] = [], pairs = new Map<number, number>();
   for (const token of brackets) {
     if ('([{'.includes(token.text)) stack.push(token);
     else {
       const open = stack.pop();
       if (open && '([{'.indexOf(open.text) === ')]}'.indexOf(token.text)) {
         pairs.set(open.start, token.start); pairs.set(token.start, open.start);
       } else stack.length = 0; // Never match across malformed nesting.
     }
   }
   const partner = pairs.get(selected.start);
   return partner === undefined ? [selected.start] : [selected.start, partner];
 }
 
 export function paintSyntax(target: HTMLElement, tokens: Token[], pair: number[] = []): void {
   const fragment = document.createDocumentFragment();
   for (const token of tokens) {
     if (!token.kind) { fragment.append(document.createTextNode(token.text)); continue; }
     const span = document.createElement('span'); span.className = `syntax-${token.kind}`; span.textContent = token.text;
     if (pair.includes(token.start)) span.classList.add(pair.length === 2 ? 'bracket-match' : 'bracket-unmatched');
     fragment.append(span);
   }
   target.replaceChildren(fragment);
 }
 
 // Unique top-level declaration heads recognized by lexical layout.
 export function definitionSites(source: string, tokens = tokenize(source)): { name: string; start: number }[] {
   const seen = new Set<string>();
   return tokens.filter(token => {
     if (token.kind !== 'definition' || token.start > 0 && source[token.start - 1] !== '\n' || seen.has(token.text)) return false;
     seen.add(token.text); return true;
   }).map(token => ({ name: token.text, start: token.start }));
 }