The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
const MAX_STRINGS = 64;
const SPECIAL = new Set([".", "*", "+", "?", "{", "}", "(", ")", "[", "]", "|", "^", "$", "\\"]);
const ESCAPED_LITERALS = new Set([
".",
"-",
"_",
"/",
"+",
"(",
")",
"[",
"]",
"{",
"}",
"$",
"^",
"|",
"?",
"*",
"\\",
]);
type Strings = string[] | null;
interface Cursor {
src: string;
at: number;
}
function product(a: string[], b: string[]): Strings {
if (a.length * b.length > MAX_STRINGS) return null;
return a.flatMap((x) => b.map((y) => x + y));
}
function parseClass(c: Cursor): Strings {
const chars: string[] = [];
c.at++;
while (c.at < c.src.length && c.src[c.at] !== "]") {
const ch = c.src[c.at]!;
if (ch === "^" || ch === "[" || (ch === "-" && chars.length > 0 && c.src[c.at + 1] !== "]")) return null;
if (ch === "\\") {
const next = c.src[c.at + 1];
if (!next || !ESCAPED_LITERALS.has(next)) return null;
chars.push(next);
c.at += 2;
continue;
}
chars.push(ch);
c.at++;
}
if (c.src[c.at] !== "]") return null;
c.at++;
return chars.length ? chars : null;
}
function parseAtom(c: Cursor): Strings {
const ch = c.src[c.at]!;
if (ch === "(") {
c.at += c.src.startsWith("(?:", c.at) ? 3 : 1;
if (c.src[c.at] === "?") return null;
const inner = parseAlternation(c);
if (inner === null || c.src[c.at] !== ")") return null;
c.at++;
return inner;
}
if (ch === "[") return parseClass(c);
if (ch === "\\") {
const next = c.src[c.at + 1];
if (!next || !ESCAPED_LITERALS.has(next)) return null;
c.at += 2;
return [next];
}
if (SPECIAL.has(ch)) return null;
c.at++;
return [ch];
}
function parseConcat(c: Cursor): Strings {
let out: string[] = [""];
while (c.at < c.src.length && c.src[c.at] !== "|" && c.src[c.at] !== ")") {
const atom = parseAtom(c);
if (atom === null) return null;
const quantifier = c.src[c.at];
if (quantifier === "*" || quantifier === "+" || quantifier === "{") return null;
const options = quantifier === "?" ? [...atom, ""] : atom;
if (quantifier === "?") c.at++;
const next = product(out, options);
if (next === null) return null;
out = next;
}
return out;
}
function parseAlternation(c: Cursor): Strings {
const out: string[] = [];
for (;;) {
const branch = parseConcat(c);
if (branch === null) return null;
out.push(...branch);
if (out.length > MAX_STRINGS) return null;
if (c.src[c.at] !== "|") return out;
c.at++;
}
}
function finiteStrings(src: string): Strings {
const c = { src, at: 0 };
const out = parseAlternation(c);
return out !== null && c.at === src.length ? out : null;
}
interface TopLevel {
alternation: boolean;
lastDot: number;
}
function scanTopLevel(src: string): TopLevel {
let depth = 0;
let inClass = false;
let lastDot = -1;
let alternation = false;
for (let i = 0; i < src.length; i++) {
const ch = src[i];
if (ch === "\\") {
if (!inClass && depth === 0 && src[i + 1] === ".") lastDot = i;
i++;
} else if (inClass) {
if (ch === "]") inClass = false;
} else if (ch === "[") inClass = true;
else if (ch === "(") depth++;
else if (ch === ")") depth--;
else if (ch === "|" && depth === 0) alternation = true;
}
return { alternation, lastDot };
}
export function extensionKeys(src: string): string[] | null {
if (!src.endsWith("$") || src.endsWith("\\$")) return null;
const { alternation, lastDot } = scanTopLevel(src);
if (alternation || lastDot < 0) return null;
const tail = finiteStrings(src.slice(lastDot + 2, -1));
if (tail === null) return null;
return [...new Set(tail.map((s) => s.slice(s.lastIndexOf(".") + 1)))];
}
export function firstCharKeys(src: string): string[] | null {
if (!src.startsWith("^") || scanTopLevel(src).alternation || src.length < 2) return null;
const c = { src, at: 1 };
const atom = parseAtom(c);
const quantifier = src[c.at];
if (atom === null || quantifier === "?" || quantifier === "*" || quantifier === "+" || quantifier === "{") {
return null;
}
if (atom.some((s) => s === "")) return null;
return [...new Set(atom.map((s) => s[0]!))];
}
export interface IndexedPattern {
re: RegExp;
source: string;
path: boolean;
order: number;
}
export interface PatternIndex<T extends IndexedPattern> {
find(name: string, path: string | null): T | undefined;
}
function add<T>(map: Map<string, T[]>, key: string, item: T) {
const list = map.get(key);
if (list) list.push(item);
else map.set(key, [item]);
}
const NONE: readonly never[] = [];
export function createPatternIndex<T extends IndexedPattern>(
patterns: readonly T[],
accept: (pattern: T, name: string, path: string | null) => boolean = (p, name, path) => {
const subject = p.path ? path : name;
return subject !== null && p.re.test(subject);
},
): PatternIndex<T> {
const byExt = new Map<string, T[]>();
const byFirst = new Map<string, T[]>();
const generic: T[] = [];
for (const p of patterns) {
const ext = extensionKeys(p.source);
if (ext) {
for (const key of new Set(ext.map((k) => k.toLowerCase()))) add(byExt, key, p);
continue;
}
const first = p.path ? null : firstCharKeys(p.source);
if (first) for (const key of new Set(first.map((k) => k.toLowerCase()))) add(byFirst, key, p);
else generic.push(p);
}
return {
find(name, path) {
const dot = name.lastIndexOf(".");
const lists = [
generic,
dot >= 0 ? (byExt.get(name.slice(dot + 1).toLowerCase()) ?? NONE) : NONE,
byFirst.get(name.charAt(0).toLowerCase()) ?? NONE,
];
const at = [0, 0, 0];
for (;;) {
let pick = -1;
for (let l = 0; l < 3; l++) {
const item = lists[l]![at[l]!];
if (item && (pick < 0 || item.order < lists[pick]![at[pick]!]!.order)) pick = l;
}
if (pick < 0) return undefined;
const item = lists[pick]![at[pick]!]!;
at[pick]!++;
if (accept(item, name, path)) return item;
}
},
};
}