@adecore/editor-react 0.31.12 → 0.33.0

package/dist/completion-model.js

@@ -6,23 +6,23 @@ import { compileSnippet, parseSnippet, tabOrder } from './snippet.js';
 import { indentSnippet } from './snippet-indent.js';
 const IDENTIFIER_CHARACTER = /[\p{L}\p{N}\p{M}_$]/u;
 export function isIdentifierCharacter(character) {
-    return IDENTIFIER_CHARACTER.test(character);
+  return IDENTIFIER_CHARACTER.test(character);
 }
 let lastBefore = '';
 let lastPrefix = '';
 /* The word being typed: the identifier characters at the end of the text before the caret. A list asks it of every item with the same line, so the last answer is kept. */
 export function identifierPrefix(before) {
-    if (before === lastBefore) {
-        return lastPrefix;
-    }
-    const characters = Array.from(before);
-    let start = characters.length;
-    while (start > 0 && IDENTIFIER_CHARACTER.test(characters[start - 1])) {
-        start--;
-    }
-    lastBefore = before;
-    lastPrefix = characters.slice(start).join('');
+  if (before === lastBefore) {
     return lastPrefix;
+  }
+  const characters = Array.from(before);
+  let start = characters.length;
+  while (start > 0 && IDENTIFIER_CHARACTER.test(characters[start - 1])) {
+    start--;
+  }
+  lastBefore = before;
+  lastPrefix = characters.slice(start).join('');
+  return lastPrefix;
 }
 const OPENS_VALUE = /(?:[-=!<>&|?+*/%^:,]|(?:^|[^\p{L}\p{N}_$])(?:return|new|case|in|of|instanceof|typeof|keyof|await|yield|throw|extends|implements|as|is|not|and|or|echo|print|use|import|from|clone))$/u;
 const NOT_A_VALUE = /(?:\+\+|--|\/\/|\/\*\*?|^\s*[-+*])$/;
@@ -32,36 +32,35 @@ const NOT_A_VALUE = /(?:\+\+|--|\/\/|\/\*\*?|^\s*[-+*])$/;
  * opener, a list marker and `++` or `--` open nothing.
  */
 export function opensCompletion(before, text) {
-    if (text === '(' || text === '()' || text === '[' || text === '[]') {
-        return true;
-    }
-    return text === ' ' && OPENS_VALUE.test(before) && !NOT_A_VALUE.test(before);
+  if (text === '(' || text === '()' || text === '[' || text === '[]') {
+    return true;
+  }
+  return text === ' ' && OPENS_VALUE.test(before) && !NOT_A_VALUE.test(before);
 }
 function run(start, length) {
-    return Array.from({ length }, (_, offset) => start + offset);
+  return Array.from({
+    length
+  }, (_, offset) => start + offset);
 }
 const SHAPE_LIMIT = 4000;
 const shapes = new Map();
 /* What matching reads of a label, which is the same at every keystroke of a word and costs a regular expression pass to find. */
 function shapeOf(value) {
-    const known = shapes.get(value);
-    if (known !== undefined) {
-        return known;
-    }
-    const boundaries = [...value.matchAll(/(?:^|[_$\s-])([\p{L}\p{N}])|(\p{Lu})/gu)];
-    const shape = {
-        lower: value.toLocaleLowerCase(),
-        offsets: boundaries.map((boundary) => boundary.index + (boundary[1] ? boundary[0].length - boundary[1].length : 0)),
-        initials: boundaries
-            .map((match) => match[1] ?? match[2])
-            .join('')
-            .toLocaleLowerCase()
-    };
-    if (shapes.size >= SHAPE_LIMIT) {
-        shapes.clear();
-    }
-    shapes.set(value, shape);
-    return shape;
+  const known = shapes.get(value);
+  if (known !== undefined) {
+    return known;
+  }
+  const boundaries = [...value.matchAll(/(?:^|[_$\s-])([\p{L}\p{N}])|(\p{Lu})/gu)];
+  const shape = {
+    lower: value.toLocaleLowerCase(),
+    offsets: boundaries.map(boundary => boundary.index + (boundary[1] ? boundary[0].length - boundary[1].length : 0)),
+    initials: boundaries.map(match => match[1] ?? match[2]).join('').toLocaleLowerCase()
+  };
+  if (shapes.size >= SHAPE_LIMIT) {
+    shapes.clear();
+  }
+  shapes.set(value, shape);
+  return shape;
 }
 /*
  * How well a prefix fits a label, lower being better, and which characters it matched, or undefined when
@@ -70,75 +69,98 @@ function shapeOf(value) {
  * in order for a prefix of two or more.
  */
 export function matchDetail(value, prefix) {
-    if (prefix === '') {
-        return { score: 0, positions: [] };
-    }
-    if (value.startsWith(prefix)) {
-        return { score: 0, positions: run(0, prefix.length) };
-    }
-    const { lower, offsets, initials } = shapeOf(value);
-    const query = prefix.toLocaleLowerCase();
-    if (lower.startsWith(query)) {
-        return { score: 1, positions: run(0, query.length) };
-    }
-    for (const offset of offsets) {
-        if (lower.slice(offset).startsWith(query)) {
-            return { score: 2 + offset / 1000, positions: run(offset, query.length) };
-        }
-    }
-    if (initials.startsWith(query)) {
-        return { score: 3, positions: offsets.slice(0, query.length) };
-    }
-    if (query.length < 2 || lower[0] !== query[0]) {
-        return undefined;
+  if (prefix === '') {
+    return {
+      score: 0,
+      positions: []
+    };
+  }
+  if (value.startsWith(prefix)) {
+    return {
+      score: 0,
+      positions: run(0, prefix.length)
+    };
+  }
+  const {
+    lower,
+    offsets,
+    initials
+  } = shapeOf(value);
+  const query = prefix.toLocaleLowerCase();
+  if (lower.startsWith(query)) {
+    return {
+      score: 1,
+      positions: run(0, query.length)
+    };
+  }
+  for (const offset of offsets) {
+    if (lower.slice(offset).startsWith(query)) {
+      return {
+        score: 2 + offset / 1000,
+        positions: run(offset, query.length)
+      };
     }
-    let cursor = 0;
-    const positions = [];
-    for (const character of query) {
-        const next = lower.indexOf(character, cursor);
-        if (next < 0) {
-            return undefined;
-        }
-        positions.push(next);
-        cursor = next + character.length;
+  }
+  if (initials.startsWith(query)) {
+    return {
+      score: 3,
+      positions: offsets.slice(0, query.length)
+    };
+  }
+  if (query.length < 2 || lower[0] !== query[0]) {
+    return undefined;
+  }
+  let cursor = 0;
+  const positions = [];
+  for (const character of query) {
+    const next = lower.indexOf(character, cursor);
+    if (next < 0) {
+      return undefined;
     }
-    return { score: 4 + cursor / 1000, positions };
+    positions.push(next);
+    cursor = next + character.length;
+  }
+  return {
+    score: 4 + cursor / 1000,
+    positions
+  };
 }
 export function matchScore(value, prefix) {
-    return matchDetail(value, prefix)?.score;
+  return matchDetail(value, prefix)?.score;
 }
 /* The range an item replaces when it is accepted; for an insert-or-replace edit, the one `replace` asks for. */
 export function editRangeOf(item, replace) {
-    const edit = item.textEdit;
-    if (edit === undefined) {
-        return null;
-    }
-    if ('range' in edit) {
-        return edit.range;
-    }
-    return replace ? edit.replace : edit.insert;
+  const edit = item.textEdit;
+  if (edit === undefined) {
+    return null;
+  }
+  if ('range' in edit) {
+    return edit.range;
+  }
+  return replace ? edit.replace : edit.insert;
 }
 /* Items from a result, with the list's defaults filled in so each carries its own edit range and format. */
 export function itemsOf(result) {
-    const list = result === null || Array.isArray(result) ? undefined : result;
-    const items = result === null ? [] : Array.isArray(result) ? result : result.items;
-    return {
-        incomplete: list?.isIncomplete ?? false,
-        items: items.flatMap((item) => {
-            if (typeof item?.label !== 'string') {
-                return [];
-            }
-            try {
-                return [applyCompletionDefaults(item, list?.itemDefaults, { onInvalidRange: () => undefined })];
-            }
-            catch (error) {
-                if (error instanceof TypeError || error instanceof RangeError) {
-                    return [];
-                }
-                throw error;
-            }
-        })
-    };
+  const list = result === null || Array.isArray(result) ? undefined : result;
+  const items = result === null ? [] : Array.isArray(result) ? result : result.items;
+  return {
+    incomplete: list?.isIncomplete ?? false,
+    items: items.flatMap(item => {
+      if (typeof item?.label !== 'string') {
+        return [];
+      }
+      try {
+        return [applyCompletionDefaults(item, list?.itemDefaults, {
+          onInvalidRange: () => undefined
+        })];
+      } catch (error) {
+        if (error instanceof TypeError || error instanceof RangeError) {
+          return [];
+        }
+        throw error;
+      }
+    })
+  };
 }
 /*
  * What a person has typed of an item: from the start of the range it will replace up to the caret when
@@ -146,70 +168,80 @@ export function itemsOf(result) {
  * `thisArg.` from filtering on the dot.
  */
 export function prefixFor(item, caret, lineBefore, textBetween) {
-    const range = editRangeOf(item, false);
-    if (range !== null && range.start.line === caret.line && comparePositions(range.start, caret) <= 0 && comparePositions(caret, range.end) <= 0) {
-        return textBetween({ start: range.start, end: caret });
-    }
-    return identifierPrefix(lineBefore);
+  const range = editRangeOf(item, false);
+  if (range !== null && range.start.line === caret.line && comparePositions(range.start, caret) <= 0 && comparePositions(caret, range.end) <= 0) {
+    return textBetween({
+      start: range.start,
+      end: caret
+    });
+  }
+  return identifierPrefix(lineBefore);
 }
 /*
  * The items that fit what is typed, best first: by how they match, then one the person chose lately, a
  * preselected one, and the server's own order. `recency` is higher for a choice made more recently, and 0 for none.
  */
 export function rankCompletions(items, prefixOf, recency = () => 0, limit = 150) {
-    const { compare } = labelCollator();
-    return items
-        .map((item, index) => {
-        const prefix = prefixOf(item);
-        return { item, index, prefix, score: matchScore(item.filterText ?? item.label, prefix), recent: recency(item) };
-    })
-        .filter((entry) => entry.score !== undefined)
-        .sort((left, right) => left.score - right.score ||
-        right.recent - left.recent ||
-        Number(right.item.preselect === true) - Number(left.item.preselect === true) ||
-        compare(left.item.sortText ?? left.item.label, right.item.sortText ?? right.item.label) ||
-        left.index - right.index)
-        .slice(0, limit)
-        .map(({ item, score, prefix }) => ({ item, score, prefix }));
+  const {
+    compare
+  } = labelCollator();
+  return items.map((item, index) => {
+    const prefix = prefixOf(item);
+    return {
+      item,
+      index,
+      prefix,
+      score: matchScore(item.filterText ?? item.label, prefix),
+      recent: recency(item)
+    };
+  }).filter(entry => entry.score !== undefined).sort((left, right) => left.score - right.score || right.recent - left.recent || Number(right.item.preselect === true) - Number(left.item.preselect === true) || compare(left.item.sortText ?? left.item.label, right.item.sortText ?? right.item.label) || left.index - right.index).slice(0, limit).map(({
+    item,
+    score,
+    prefix
+  }) => ({
+    item,
+    score,
+    prefix
+  }));
 }
 /* The characters of a label to mark for what was typed; none when the label is not what the server filtered on. */
 export function matchedCharacters(label, prefix) {
-    return matchDetail(label, prefix)?.positions ?? [];
+  return matchDetail(label, prefix)?.positions ?? [];
 }
 /* The first line of what a server says about where an item comes from, with a PHP `use` made into the namespace it names. */
 function sourceOf(item) {
-    const detail = item.detail?.split('\n')[0]?.trim() ?? '';
-    const imported = /^use\s+(.+)$/.exec(detail);
-    return imported === null ? detail : imported[1].slice(0, Math.max(0, imported[1].lastIndexOf('\\')));
+  const detail = item.detail?.split('\n')[0]?.trim() ?? '';
+  const imported = /^use\s+(.+)$/.exec(detail);
+  return imported === null ? detail : imported[1].slice(0, Math.max(0, imported[1].lastIndexOf('\\')));
 }
 /* What stands right-aligned after a row: the module or namespace the item comes from, else what the server calls its type. */
 export function qualifierOf(item) {
-    const description = item.labelDetails?.description?.trim() ?? '';
-    return description !== '' ? description : sourceOf(item);
+  const description = item.labelDetails?.description?.trim() ?? '';
+  return description !== '' ? description : sourceOf(item);
 }
 /*
  * The qualifier of each row of a list. Items that share a label are told apart however it takes: by the
  * qualifier, or by what the server says besides, and by a number when a server says nothing that differs.
  */
 export function qualifiersOf(items) {
-    const result = items.map(qualifierOf);
-    const groups = new Map();
-    items.forEach((item, index) => groups.set(item.label, [...(groups.get(item.label) ?? []), index]));
-    for (const indexes of groups.values()) {
-        if (indexes.length < 2 || new Set(indexes.map((index) => result[index])).size === indexes.length) {
-            continue;
-        }
-        const alternate = indexes.map((index) => sourceOf(items[index]) || result[index]);
-        const distinct = new Set(alternate).size === indexes.length && !alternate.includes('');
-        indexes.forEach((index, position) => {
-            result[index] = distinct ? alternate[position] : `${result[index] ?? ''} #${position + 1}`.trim();
-        });
+  const result = items.map(qualifierOf);
+  const groups = new Map();
+  items.forEach((item, index) => groups.set(item.label, [...(groups.get(item.label) ?? []), index]));
+  for (const indexes of groups.values()) {
+    if (indexes.length < 2 || new Set(indexes.map(index => result[index])).size === indexes.length) {
+      continue;
     }
-    return result;
+    const alternate = indexes.map(index => sourceOf(items[index]) || result[index]);
+    const distinct = new Set(alternate).size === indexes.length && !alternate.includes('');
+    indexes.forEach((index, position) => {
+      result[index] = distinct ? alternate[position] : `${result[index] ?? ''} #${position + 1}`.trim();
+    });
+  }
+  return result;
 }
 /* A snippet as the plain text it would insert: tab stops and variables vanish, placeholders and choices become their text, and the escapes of the format are undone. */
 export function snippetToText(snippet) {
-    return parseSnippet(snippet).text;
+  return parseSnippet(snippet).text;
 }
 export const METHOD_KIND = 2;
 export const FUNCTION_KIND = 3;
@@ -217,80 +249,132 @@ export const CONSTRUCTOR_KIND = 4;
 export const CLASS_KIND = 7;
 export const SNIPPET_FORMAT = 2;
 export function isCallableKind(kind) {
-    return kind === METHOD_KIND || kind === FUNCTION_KIND || kind === CONSTRUCTOR_KIND;
+  return kind === METHOD_KIND || kind === FUNCTION_KIND || kind === CONSTRUCTOR_KIND;
 }
 /* A call snippet with the call cut off, for a name that already has its parentheses: `log(${1:value})$0` becomes `log`. */
 function withoutCall(snippet) {
-    const open = snippet.search(/(?<!\\)\(/);
-    return open > 0 ? snippet.slice(0, open) : snippet;
+  const open = snippet.search(/(?<!\\)\(/);
+  return open > 0 ? snippet.slice(0, open) : snippet;
 }
 /*
  * What goes into the text for an item and the range it takes the place of, given the caret. `lineAfter` is
  * the rest of the line after the caret: an item that would add a call does not when a parenthesis follows.
  */
 export function insertionOf(item, caret, lineBefore, replace, lineAfter = '', options = {}) {
-    const raw = item.textEdit?.newText ?? item.insertText ?? item.label;
-    const edit = editRangeOf(item, replace);
-    const range = edit === null
-        ? { start: { line: caret.line, character: caret.character - identifierPrefix(lineBefore).length }, end: caret }
-        : // The word grew since the answer came, so what was typed since belongs to what is replaced.
-            { start: edit.start, end: comparePositions(edit.end, caret) < 0 && edit.end.line === caret.line ? caret : edit.end };
-    if (item.insertTextFormat !== SNIPPET_FORMAT) {
-        const adjusted = item.insertTextMode === 2
-            ? indentSnippet({ text: raw, stops: [] }, options.indentationBefore ?? lineBefore.slice(0, range.start.character))
-            : { text: raw, stops: [] };
-        return { range, text: adjusted.text, stops: [], ...(adjusted.limited ? { limited: true } : {}) };
-    }
-    const followed = range.end.line === caret.line && lineAfter.slice(Math.max(0, range.end.character - caret.character)).startsWith('(');
-    const source = followed && isCallableKind(item.kind) ? withoutCall(raw) : raw;
-    const template = options.template?.source === source ? options.template : compileSnippet(source);
-    const rendered = template.render(options.resolve, options.variableTransforms);
-    const parsed = item.insertTextMode === 2 ? indentSnippet(rendered, options.indentationBefore ?? lineBefore.slice(0, range.start.character)) : rendered;
+  const raw = item.textEdit?.newText ?? item.insertText ?? item.label;
+  const edit = editRangeOf(item, replace);
+  const range = edit === null ? {
+    start: {
+      line: caret.line,
+      character: caret.character - identifierPrefix(lineBefore).length
+    },
+    end: caret
+  } :
+  // The word grew since the answer came, so what was typed since belongs to what is replaced.
+  {
+    start: edit.start,
+    end: comparePositions(edit.end, caret) < 0 && edit.end.line === caret.line ? caret : edit.end
+  };
+  if (item.insertTextFormat !== SNIPPET_FORMAT) {
+    const adjusted = item.insertTextMode === 2 ? indentSnippet({
+      text: raw,
+      stops: []
+    }, options.indentationBefore ?? lineBefore.slice(0, range.start.character)) : {
+      text: raw,
+      stops: []
+    };
     return {
-        range,
-        text: parsed.text,
-        stops: tabOrder(parsed),
-        fields: parsed.fields,
-        ...(options.variableTransforms !== undefined || rendered.transforms === undefined
-            ? {}
-            : {
-                variableTransforms: rendered.transforms.map((range) => ({ ...range.transform, value: rendered.text.slice(range.start, range.end) }))
-            }),
-        ...(parsed.limited ? { limited: true } : {})
+      range,
+      text: adjusted.text,
+      stops: [],
+      ...(adjusted.limited ? {
+        limited: true
+      } : {})
     };
+  }
+  const followed = range.end.line === caret.line && lineAfter.slice(Math.max(0, range.end.character - caret.character)).startsWith('(');
+  const source = followed && isCallableKind(item.kind) ? withoutCall(raw) : raw;
+  const template = options.template?.source === source ? options.template : compileSnippet(source);
+  const rendered = template.render(options.resolve, options.variableTransforms);
+  const parsed = item.insertTextMode === 2 ? indentSnippet(rendered, options.indentationBefore ?? lineBefore.slice(0, range.start.character)) : rendered;
+  return {
+    range,
+    text: parsed.text,
+    stops: tabOrder(parsed),
+    fields: parsed.fields,
+    ...(options.variableTransforms !== undefined || rendered.transforms === undefined ? {} : {
+      variableTransforms: rendered.transforms.map(range => ({
+        ...range.transform,
+        value: rendered.text.slice(range.start, range.end)
+      }))
+    }),
+    ...(parsed.limited ? {
+      limited: true
+    } : {})
+  };
 }
 /*
  * The same insertion at every other caret that has the word the primary caret has before it, so a name typed at
  * several carets is completed at all of them. A caret that is inside a selection, or after other text, is left alone.
  */
 export function mirroredInsertions(carets, primary, caret, text, insertion, includeSelections = false) {
-    const before = insertion.range.start.line === caret.line ? caret.character - insertion.range.start.character : -1;
-    const after = insertion.range.end.line === caret.line ? insertion.range.end.character - caret.character : -1;
-    if (before < 0 || after < 0) {
-        return [];
+  const before = insertion.range.start.line === caret.line ? caret.character - insertion.range.start.character : -1;
+  const after = insertion.range.end.line === caret.line ? insertion.range.end.character - caret.character : -1;
+  if (before < 0 || after < 0) {
+    return [];
+  }
+  const typed = text({
+    start: insertion.range.start,
+    end: caret
+  });
+  const replaced = text({
+    start: caret,
+    end: insertion.range.end
+  });
+  return carets.flatMap(other => {
+    const at = includeSelections ? other.end : other.start;
+    if (comparePositions(other.start, primary.start) === 0 && comparePositions(other.end, primary.end) === 0) {
+      return [];
     }
-    const typed = text({ start: insertion.range.start, end: caret });
-    const replaced = text({ start: caret, end: insertion.range.end });
-    return carets.flatMap((other) => {
-        const at = includeSelections ? other.end : other.start;
-        if (comparePositions(other.start, primary.start) === 0 && comparePositions(other.end, primary.end) === 0) {
-            return [];
-        }
-        if ((!includeSelections && comparePositions(other.start, other.end) !== 0) || at.character < before) {
-            return [];
-        }
-        const range = { start: { line: at.line, character: at.character - before }, end: { line: at.line, character: at.character + after } };
-        const preceding = range.start.character > 0 ? text({ start: { line: at.line, character: range.start.character - 1 }, end: range.start }) : '';
-        const startsWord = preceding === '' || !isIdentifierCharacter(preceding);
-        const matches = startsWord && text({ start: range.start, end: at }) === typed && text({ start: at, end: range.end }) === replaced;
-        return matches ? [{ range, text: insertion.text }] : [];
-    });
+    if (!includeSelections && comparePositions(other.start, other.end) !== 0 || at.character < before) {
+      return [];
+    }
+    const range = {
+      start: {
+        line: at.line,
+        character: at.character - before
+      },
+      end: {
+        line: at.line,
+        character: at.character + after
+      }
+    };
+    const preceding = range.start.character > 0 ? text({
+      start: {
+        line: at.line,
+        character: range.start.character - 1
+      },
+      end: range.start
+    }) : '';
+    const startsWord = preceding === '' || !isIdentifierCharacter(preceding);
+    const matches = startsWord && text({
+      start: range.start,
+      end: at
+    }) === typed && text({
+      start: at,
+      end: range.end
+    }) === replaced;
+    return matches ? [{
+      range,
+      text: insertion.text
+    }] : [];
+  });
 }
 export function documentationText(documentation) {
-    if (documentation === undefined) {
-        return '';
-    }
-    return typeof documentation === 'string' ? documentation : documentation.kind === 'plaintext' ? escapeMarkdown(documentation.value) : documentation.value;
+  if (documentation === undefined) {
+    return '';
+  }
+  return typeof documentation === 'string' ? documentation : documentation.kind === 'plaintext' ? escapeMarkdown(documentation.value) : documentation.value;
 }
 /* A detail line that only says where an item comes from: a PHP `use` or an auto import. */
 export const SOURCE_LINE = /^(?:use\s|Auto import from\b)/;
@@ -300,75 +384,81 @@ export const SOURCE_LINE = /^(?:use\s|Auto import from\b)/;
  * kept apart, since it is no code.
  */
 export function completionDocsOf(item, highlightLanguage) {
-    const lines = (item.detail ?? '').trim().split('\n');
-    const hasSource = SOURCE_LINE.test(lines[0] ?? '');
-    const source = hasSource ? lines[0].trim() : '';
-    const code = (hasSource ? lines.slice(1) : lines).join('\n').trim();
-    const parsed = splitSignatures(documentationText(item.documentation));
-    const text = {
-        signatures: code === '' ? parsed.signatures : [{ language: highlightLanguage, code }, ...parsed.signatures],
-        markdown: parsed.markdown
-    };
-    return source === '' && isEmptyHover(text) ? null : { source, text };
+  const lines = (item.detail ?? '').trim().split('\n');
+  const hasSource = SOURCE_LINE.test(lines[0] ?? '');
+  const source = hasSource ? lines[0].trim() : '';
+  const code = (hasSource ? lines.slice(1) : lines).join('\n').trim();
+  const parsed = splitSignatures(documentationText(item.documentation));
+  const text = {
+    signatures: code === '' ? parsed.signatures : [{
+      language: highlightLanguage,
+      code
+    }, ...parsed.signatures],
+    markdown: parsed.markdown
+  };
+  return source === '' && isEmptyHover(text) ? null : {
+    source,
+    text
+  };
 }
 const KIND_LETTERS = {
-    1: 't',
-    2: 'm',
-    3: 'f',
-    4: 'c',
-    5: 'p',
-    6: 'v',
-    7: 'c',
-    8: 'i',
-    9: 'm',
-    10: 'p',
-    11: 'u',
-    12: 'v',
-    13: 'e',
-    14: 'k',
-    15: 's',
-    16: 'c',
-    17: 'f',
-    18: 'r',
-    19: 'f',
-    20: 'e',
-    21: 'k',
-    22: 's',
-    23: 'e',
-    24: 'o',
-    25: 't'
+  1: 't',
+  2: 'm',
+  3: 'f',
+  4: 'c',
+  5: 'p',
+  6: 'v',
+  7: 'c',
+  8: 'i',
+  9: 'm',
+  10: 'p',
+  11: 'u',
+  12: 'v',
+  13: 'e',
+  14: 'k',
+  15: 's',
+  16: 'c',
+  17: 'f',
+  18: 'r',
+  19: 'f',
+  20: 'e',
+  21: 'k',
+  22: 's',
+  23: 'e',
+  24: 'o',
+  25: 't'
 };
 const KIND_TONES = {
-    2: 'callable',
-    3: 'callable',
-    4: 'callable',
-    5: 'value',
-    6: 'value',
-    10: 'value',
-    12: 'value',
-    20: 'value',
-    21: 'value',
-    7: 'type',
-    8: 'type',
-    9: 'type',
-    13: 'type',
-    22: 'type',
-    25: 'type'
+  2: 'callable',
+  3: 'callable',
+  4: 'callable',
+  5: 'value',
+  6: 'value',
+  10: 'value',
+  12: 'value',
+  20: 'value',
+  21: 'value',
+  7: 'type',
+  8: 'type',
+  9: 'type',
+  13: 'type',
+  22: 'type',
+  25: 'type'
 };
 export function kindLetterOf(kind) {
-    return kind === undefined ? '·' : (KIND_LETTERS[kind] ?? '·');
+  return kind === undefined ? '·' : KIND_LETTERS[kind] ?? '·';
 }
 export function kindToneOf(kind) {
-    return kind === undefined ? 'other' : (KIND_TONES[kind] ?? 'other');
+  return kind === undefined ? 'other' : KIND_TONES[kind] ?? 'other';
 }
 /*
  * The rows of a list worth drawing: the ones in view, a few on each side, and the active one with the
  * same margin, so the rows between never leave a gap. The rest is only space.
  */
 export function rowWindow(scrollTop, active, total, rowHeight, visible, margin, padding) {
-    const shown = Math.floor(Math.max(0, scrollTop - padding) / rowHeight);
-    return {
-        first: Math.max(0, Math.min(shown, active) - margin),
-        last: Math.min(total, Math.max(shown + visible + 1, active + 1) + margin)
-    };
-}
+  const shown = Math.floor(Math.max(0, scrollTop - padding) / rowHeight);
+  return {
+    first: Math.max(0, Math.min(shown, active) - margin),
+    last: Math.min(total, Math.max(shown + visible + 1, active + 1) + margin)
+  };
+}