synabun 2.0.0-beta → 2.0.5

package/neural-interface/public/shared/editor/editor-doc.js

@@ -0,0 +1,257 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — Code editor: what a file is on disk
+// ═══════════════════════════════════════════
+//
+// CodeMirror holds every line break as "\n". These helpers read what the file
+// used (line ending, byte-order mark, indentation) when it is opened, and write
+// the document back the same way when it is saved. No DOM and no imports: loaded
+// by `node --test` as it is.
+
+export const BOM = '\uFEFF';
+const REPLACEMENT = '\uFFFD';
+
+/**
+ * Take a leading byte-order mark off `content`.
+ * @param {string} content what the server sent
+ * @param {boolean} [reported] the server's `bom` field. A server that sends it has already taken the mark off;
+ *   one that does not (it predates the field) sends the mark as the first character.
+ * @returns {{ text: string, bom: boolean }}
+ */
+export function splitBom(content, reported) {
+  const text = String(content ?? '');
+  if (typeof reported === 'boolean') return { text, bom: reported };
+  return text.charCodeAt(0) === 0xFEFF ? { text: text.slice(1), bom: true } : { text, bom: false };
+}
+
+/**
+ * The line ending a text uses. `eol` is the style it is saved in: the more common of LF and CRLF (LF when
+ * neither leads). `mixed` says the text holds more than one kind of line break, a lone CR included, so a save
+ * rewrites some of them.
+ * @returns {{ eol: 'LF' | 'CRLF', mixed: boolean, counts: { lf: number, crlf: number, cr: number } }}
+ */
+export function detectLineEnding(text) {
+  const s = String(text ?? '');
+  let lf = 0; let crlf = 0; let cr = 0;
+  for (let i = s.indexOf('\n'); i !== -1; i = s.indexOf('\n', i + 1)) {
+    if (i > 0 && s.charCodeAt(i - 1) === 13) crlf++;
+    else lf++;
+  }
+  for (let i = s.indexOf('\r'); i !== -1; i = s.indexOf('\r', i + 1)) {
+    if (s.charCodeAt(i + 1) !== 10) cr++;
+  }
+  const kinds = (lf ? 1 : 0) + (crlf ? 1 : 0) + (cr ? 1 : 0);
+  return { eol: crlf > lf ? 'CRLF' : 'LF', mixed: kinds > 1, counts: { lf, crlf, cr } };
+}
+
+const SPACE_STEPS = [2, 4, 8];
+/** The width a tab is drawn at when nothing says otherwise. */
+export const DEFAULT_TAB_WIDTH = 4;
+/** What Tab inserts in a file that shows no indentation of its own. */
+export const DEFAULT_SPACE_STEP = 2;
+
+/**
+ * How a text is indented, read from its leading whitespace: with tabs, or with the step of 2, 4 or 8 spaces
+ * that most often separates one line from the line before it.
+ * @param {string} text
+ * @param {{ maxLines?: number }} [o] lines read from the start (a large file is not read whole)
+ * @returns {{ kind: 'spaces' | 'tabs', size: number, detected: boolean }} `size` is the space step, or the
+ *   default tab width for a file indented with tabs; `detected` is false when the text gave no evidence
+ */
+export function detectIndentation(text, { maxLines = 5000 } = {}) {
+  const s = String(text ?? '');
+  let tabLines = 0; let spaceLines = 0;
+  const steps = new Map(SPACE_STEPS.map((n) => [n, 0]));
+  let previous = 0;      // leading spaces of the last line that had content and was not indented with a tab
+  let at = 0;
+  for (let n = 0; n < maxLines && at <= s.length; n++) {
+    let end = s.indexOf('\n', at);
+    if (end === -1) end = s.length;
+    let i = at;
+    let spaces = 0; let tab = false;
+    for (; i < end; i++) {
+      const c = s.charCodeAt(i);
+      if (c === 32) spaces++;
+      else if (c === 9) tab = true;
+      else break;
+    }
+    const blank = i >= end || s.charCodeAt(i) === 13;
+    if (!blank) {
+      if (tab) tabLines++;
+      else {
+        if (spaces) spaceLines++;
+        const step = Math.abs(spaces - previous);
+        if (steps.has(step)) steps.set(step, steps.get(step) + 1);
+        previous = spaces;
+      }
+    }
+    at = end + 1;
+  }
+  if (tabLines > spaceLines) return { kind: 'tabs', size: DEFAULT_TAB_WIDTH, detected: true };
+  let best = 0; let bestCount = 0;
+  for (const n of SPACE_STEPS) {
+    if (steps.get(n) > bestCount) { best = n; bestCount = steps.get(n); }
+  }
+  if (!best) return { kind: 'spaces', size: DEFAULT_SPACE_STEP, detected: false };
+  return { kind: 'spaces', size: best, detected: true };
+}
+
+/**
+ * The indentation the editor uses for a file: what was detected, unless a preference says otherwise.
+ * @param {{ kind: 'spaces' | 'tabs', size: number }} detected from detectIndentation()
+ * @param {{ tabSize?: 'auto' | number, indentWith?: 'auto' | 'spaces' | 'tabs' }} [editing] the `editing` preferences
+ * @returns {{ kind: 'spaces' | 'tabs', tabSize: number, unit: string }} `unit` is what one level of indentation inserts
+ */
+export function resolveIndentation(detected, editing = {}) {
+  const found = detected && (detected.kind === 'tabs' || detected.kind === 'spaces')
+    ? detected : { kind: 'spaces', size: DEFAULT_SPACE_STEP };
+  const kind = editing.indentWith === 'tabs' || editing.indentWith === 'spaces' ? editing.indentWith : found.kind;
+  const wanted = Number(editing.tabSize);
+  let tabSize;
+  if (editing.tabSize !== 'auto' && Number.isInteger(wanted) && wanted >= 1 && wanted <= 16) tabSize = wanted;
+  else if (kind === found.kind) tabSize = found.size;
+  else tabSize = kind === 'tabs' ? DEFAULT_TAB_WIDTH : DEFAULT_SPACE_STEP;
+  return { kind, tabSize, unit: kind === 'tabs' ? '\t' : ' '.repeat(tabSize) };
+}
+
+/**
+ * The indentation a file uses when the user picked one in the status bar: that choice, over what was detected
+ * and over the preferences. Without a choice it is resolveIndentation().
+ * @param {{ kind: 'spaces' | 'tabs', size: number }} detected from detectIndentation()
+ * @param {{ tabSize?: 'auto' | number, indentWith?: string }} [editing] the `editing` preferences
+ * @param {{ kind: 'spaces', size: number } | { kind: 'tabs' } | null} [choice]
+ * @returns {{ kind: 'spaces' | 'tabs', tabSize: number, unit: string }}
+ */
+export function chooseIndentation(detected, editing = {}, choice = null) {
+  if (!choice) return resolveIndentation(detected, editing);
+  if (choice.kind === 'tabs') {
+    // How wide a tab is drawn is not part of the choice: the preference, else what the file showed.
+    const wanted = Number(editing.tabSize);
+    const tabSize = editing.tabSize !== 'auto' && Number.isInteger(wanted) && wanted >= 1 && wanted <= 16
+      ? wanted : (detected?.kind === 'tabs' ? detected.size : DEFAULT_TAB_WIDTH);
+    return { kind: 'tabs', tabSize, unit: '\t' };
+  }
+  const size = SPACE_STEPS.includes(choice.size) ? choice.size : DEFAULT_SPACE_STEP;
+  return { kind: 'spaces', tabSize: size, unit: ' '.repeat(size) };
+}
+
+/**
+ * The one change that turns `before` into `after`: what lies between the start and the end the two share.
+ * A file reloaded from disk is applied this way, so the caret, the view and the undo history outside the
+ * change stay where they are.
+ * @returns {{ from: number, to: number, insert: string } | null} null when the texts are the same
+ */
+export function minimalChange(before, after) {
+  const a = String(before ?? '');
+  const b = String(after ?? '');
+  if (a === b) return null;
+  const shortest = Math.min(a.length, b.length);
+  let start = 0;
+  while (start < shortest && a.charCodeAt(start) === b.charCodeAt(start)) start++;
+  let end = 0;
+  while (end < shortest - start && a.charCodeAt(a.length - 1 - end) === b.charCodeAt(b.length - 1 - end)) end++;
+  return { from: start, to: a.length - end, insert: b.slice(start, b.length - end) };
+}
+
+/**
+ * The text a save writes: `text` (line breaks as "\n", the way CodeMirror holds it) in the file's line ending,
+ * behind its byte-order mark when it had one.
+ */
+export function serializeDocument(text, { eol = 'LF', bom = false } = {}) {
+  const body = eol === 'CRLF' ? String(text ?? '').replace(/\n/g, '\r\n') : String(text ?? '');
+  return bom ? BOM + body : body;
+}
+
+/**
+ * Whether `content` lost bytes when it was decoded. A server that predates the encoding check decodes a file
+ * that is not UTF-8 anyway, with U+FFFD in place of each invalid sequence: the text then no longer encodes to
+ * the file's size, and saving it would write the damage to disk.
+ * @param {string} content the text as received, byte-order mark included
+ * @param {number} sizeOnDisk the size the server reported, in bytes
+ */
+export function looksLossyDecoded(content, sizeOnDisk) {
+  const s = String(content ?? '');
+  if (!Number.isFinite(sizeOnDisk) || !s.includes(REPLACEMENT)) return false;
+  return new TextEncoder().encode(s).length !== sizeOnDisk;
+}
+
+/**
+ * The document position of a 1-based line and column, held inside the document: a line past the end is the
+ * last line, a column past the end of its line is the end of that line.
+ * @param {{ lines: number, line: (n: number) => { from: number, length: number } }} doc a CodeMirror Text
+ * @returns {{ pos: number, line: number, column: number }}
+ */
+export function positionAt(doc, lineNumber, columnNumber = 1) {
+  const line = Math.min(Math.max(1, Math.floor(Number(lineNumber)) || 1), Math.max(1, doc.lines));
+  const info = doc.line(line);
+  const column = Math.min(Math.max(1, Math.floor(Number(columnNumber)) || 1), info.length + 1);
+  return { pos: info.from + column - 1, line, column };
+}
+
+/**
+ * What a "go to line" field asks for: `12`, `12:8` or `12,8`.
+ * @returns {{ line: number, column: number } | null} null when it is not a line number
+ */
+export function parseLineTarget(input) {
+  const m = /^\s*(\d{1,9})\s*(?:[:,]\s*(\d{1,9})\s*)?$/.exec(String(input ?? ''));
+  if (!m) return null;
+  const line = Number(m[1]);
+  if (line < 1) return null;
+  return { line, column: m[2] ? Math.max(1, Number(m[2])) : 1 };
+}
+
+/** Above this size the minimap, the git markers and the problem check are off for a document. */
+export const LARGE_DOCUMENT_BYTES = 2 * 1024 * 1024;
+
+/**
+ * Whether a document is too large for the minimap, the git markers and the problem check.
+ * @param {{ size?: number, length?: number }} o `size`: the file on disk, in bytes; `length`: the text in the editor
+ */
+export function isLargeDocument({ size = 0, length = 0 } = {}) {
+  return Math.max(Number(size) || 0, Number(length) || 0) > LARGE_DOCUMENT_BYTES;
+}
+
+/**
+ * What a save changes in the text before it is written, for the two on-save preferences.
+ *   trimTrailingWhitespace  spaces and tabs at the end of a line go
+ *   insertFinalNewline      the text ends with exactly one line break: a missing one is added, empty lines after
+ *                           the last line with text go (with trimming on, a line of only spaces is an empty line)
+ * An empty text stays empty. With both off nothing changes.
+ * @param {string} text line breaks as "\n", the way CodeMirror holds it
+ * @param {{ trimTrailingWhitespace?: boolean, insertFinalNewline?: boolean }} [o]
+ * @returns {{ from: number, to: number, insert: string }[]} changes in document order that do not touch each other
+ */
+export function saveFixes(text, { trimTrailingWhitespace = false, insertFinalNewline = false } = {}) {
+  const s = String(text ?? '');
+  const changes = [];
+  if (!s || (!trimTrailingWhitespace && !insertFinalNewline)) return changes;
+  let contentEnd = s.length;
+  let ending = null;
+  if (insertFinalNewline) {
+    const blank = trimTrailingWhitespace ? (c) => c === 10 || c === 32 || c === 9 : (c) => c === 10;
+    while (contentEnd > 0 && blank(s.charCodeAt(contentEnd - 1))) contentEnd--;
+    const wanted = contentEnd === 0 ? '' : '\n';
+    if (s.slice(contentEnd) !== wanted) ending = { from: contentEnd, to: s.length, insert: wanted };
+    else contentEnd = s.length;   // the end is as it should be: only lines are trimmed
+  }
+  if (trimTrailingWhitespace) {
+    const trailing = /[ \t]+$/gm;
+    for (let m = trailing.exec(s); m; m = trailing.exec(s)) {
+      if (ending && m.index >= ending.from) break;   // what follows is replaced with the ending
+      changes.push({ from: m.index, to: m.index + m[0].length, insert: '' });
+    }
+  }
+  if (ending) changes.push(ending);
+  return changes;
+}
+
+/** `text` with the changes of saveFixes() (or any changes in document order) applied. */
+export function applyChanges(text, changes) {
+  const s = String(text ?? '');
+  let out = '';
+  let at = 0;
+  for (const change of changes) {
+    out += s.slice(at, change.from) + change.insert;
+    at = change.to;
+  }
+  return out + s.slice(at);
+}

package/neural-interface/public/shared/editor/editor-git-logic.js

@@ -0,0 +1,131 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — Code editor: which lines differ from the last commit
+// ═══════════════════════════════════════════
+//
+// The decisions behind the git markers (editor-git.js draws them): what the
+// server said about a file's committed version, which lines of the document
+// differ from it, and what the gutter shows for them. A line comparison by the
+// O(ND) method, bounded: beyond its limit the stretch that differs is marked as
+// one change instead of being taken apart. No DOM and no imports: loaded by
+// `node --test` as it is.
+
+/** Edits a comparison takes apart; a stretch that needs more is one "modified" block. */
+export const DIFF_MAX_EDITS = 1500;
+
+/**
+ * What GET /api/file-head answered.
+ * @param {{ status?: number, body?: object | null }} response
+ * @returns {{ tracked: boolean, text: string | null }} `text`: the committed version, line breaks as "\n"; null
+ *   when git does not know the file, when what it holds is not text, or when the server could not say
+ */
+export function readHeadResponse({ status = 0, body = null } = {}) {
+  if (status !== 200 || body?.ok !== true || body.tracked !== true) return { tracked: false, text: null };
+  if (typeof body.content !== 'string') return { tracked: true, text: null };
+  return { tracked: true, text: body.content.replace(/\r\n?/g, '\n') };
+}
+
+/**
+ * The stretches where two lists of lines differ.
+ * @param {string[]} before the committed lines
+ * @param {string[]} after the document's lines
+ * @param {{ maxEdits?: number }} [o]
+ * @returns {{ aFrom: number, aTo: number, bFrom: number, bTo: number }[]} in order; each replaces lines
+ *   `aFrom`..`aTo` of `before` with lines `bFrom`..`bTo` of `after` (0-based, the end not included)
+ */
+export function diffLines(before, after, { maxEdits = DIFF_MAX_EDITS } = {}) {
+  const a = before; const b = after;
+  let start = 0;
+  const shortest = Math.min(a.length, b.length);
+  while (start < shortest && a[start] === b[start]) start++;
+  let endA = a.length; let endB = b.length;
+  while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) { endA--; endB--; }
+  if (start === endA && start === endB) return [];
+  const whole = [{ aFrom: start, aTo: endA, bFrom: start, bTo: endB }];
+  if (start === endA || start === endB) return whole;
+
+  // The middle, each distinct line as a number: comparing lines is then comparing numbers.
+  const ids = new Map();
+  const intern = (line) => { let id = ids.get(line); if (id === undefined) { id = ids.size; ids.set(line, id); } return id; };
+  const n = endA - start; const m = endB - start;
+  const x0 = new Int32Array(n); const y0 = new Int32Array(m);
+  for (let i = 0; i < n; i++) x0[i] = intern(a[start + i]);
+  for (let i = 0; i < m; i++) y0[i] = intern(b[start + i]);
+
+  const max = Math.min(n + m, Math.max(1, maxEdits));
+  const offset = max + 1;
+  const v = new Int32Array(2 * max + 3);
+  const trace = [];
+  let found = -1;
+  for (let d = 0; d <= max && found < 0; d++) {
+    trace.push(v.slice(offset - d, offset + d + 1));   // the furthest points before this round, for the way back
+    for (let k = -d; k <= d; k += 2) {
+      let x = (k === -d || (k !== d && v[offset + k - 1] < v[offset + k + 1])) ? v[offset + k + 1] : v[offset + k - 1] + 1;
+      let y = x - k;
+      while (x < n && y < m && x0[x] === y0[y]) { x++; y++; }
+      v[offset + k] = x;
+      if (x >= n && y >= m) { found = d; break; }
+    }
+  }
+  if (found < 0) return whole;
+
+  // Back from the end: the lines both have are what separates one stretch from the next.
+  const hunks = [];
+  let open = null;
+  const edit = (x, y, dx, dy) => {
+    if (open && open.aFrom === x + dx && open.bFrom === y + dy) { open.aFrom = x; open.bFrom = y; return; }
+    open = { aFrom: x, aTo: x + dx, bFrom: y, bTo: y + dy };
+    hunks.push(open);
+  };
+  let x = n; let y = m;
+  for (let d = found; d > 0; d--) {
+    const prev = trace[d];
+    const at = (k) => prev[k + d];
+    const k = x - y;
+    const down = k === -d || (k !== d && at(k - 1) < at(k + 1));
+    const prevK = down ? k + 1 : k - 1;
+    const prevX = at(prevK);
+    const prevY = prevX - prevK;
+    if (down) edit(prevX, prevY, 0, 1);   // a line of `after` that `before` does not have
+    else edit(prevX, prevY, 1, 0);        // a line of `before` that is gone
+    x = prevX; y = prevY;
+  }
+  return hunks.reverse().map((hunk) => ({ aFrom: hunk.aFrom + start, aTo: hunk.aTo + start, bFrom: hunk.bFrom + start, bTo: hunk.bTo + start }));
+}
+
+/**
+ * What the gutter shows for the stretches diffLines() found.
+ * @param {{ aFrom: number, aTo: number, bFrom: number, bTo: number }[]} hunks
+ * @param {number} lineCount lines in the document
+ * @returns {{ from: number, to: number, kind: 'added' | 'modified' | 'deleted', after?: boolean }[]} `from`..`to`:
+ *   lines of the document, 1-based, both included. `deleted` marks one line: the one committed lines were removed
+ *   in front of, or (with `after`) the last line when they were removed behind it.
+ */
+export function lineMarks(hunks, lineCount) {
+  const marks = [];
+  const last = Math.max(1, lineCount);
+  for (const hunk of hunks) {
+    if (hunk.bTo > hunk.bFrom) {
+      marks.push({ from: hunk.bFrom + 1, to: hunk.bTo, kind: hunk.aTo > hunk.aFrom ? 'modified' : 'added' });
+    } else if (hunk.aTo > hunk.aFrom) {
+      const after = hunk.bFrom >= last;
+      marks.push({ from: after ? last : hunk.bFrom + 1, to: after ? last : hunk.bFrom + 1, kind: 'deleted', ...(after ? { after: true } : {}) });
+    }
+  }
+  return marks;
+}
+
+/**
+ * The marks for a document against its committed version.
+ * @param {string[]} headLines the committed lines
+ * @param {string[]} lines the document's lines
+ */
+export function gitMarks(headLines, lines, options) {
+  return lineMarks(diffLines(headLines, lines, options), lines.length);
+}
+
+/** How many lines each kind of mark covers: `{ added, modified, deleted }` (`deleted` counts places, not lines). */
+export function countMarks(marks) {
+  const count = { added: 0, modified: 0, deleted: 0 };
+  for (const mark of marks) count[mark.kind] += mark.kind === 'deleted' ? 1 : mark.to - mark.from + 1;
+  return count;
+}

package/neural-interface/public/shared/editor/editor-git.js

@@ -0,0 +1,95 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — Code editor: git markers
+// ═══════════════════════════════════════════
+//
+// A thin column next to the fold arrows that says which lines differ from the
+// last commit: added, modified, and where committed lines were removed. Which
+// lines those are is decided in editor-git-logic.js; the panel fetches the
+// committed text (GET /api/file-head), compares after edits and saves, and
+// hands the result here as an effect. The marks are part of the document's
+// state, so each tab keeps its own, and they move with the text until the next
+// comparison. The Diff view of the file against the last commit is the inline
+// comparison of editor-compare.js, fed the committed text.
+// Takes the vendored bundle as an argument: no imports.
+
+/** A comparison runs this long after the last edit. */
+export const GIT_REFRESH_MS = 300;
+
+/**
+ * @param {object} cm the vendored CodeMirror bundle (editor-loader.js)
+ */
+export function editorGit(cm) {
+  const { GutterMarker, RangeSet, RangeSetBuilder, StateEffect, StateField, gutter } = cm;
+
+  class ChangeMarker extends GutterMarker {
+    constructor(kind, after = false) {
+      super();
+      this.kind = kind;
+      this.after = after;
+      this.elementClass = `cm-gitLine cm-gitLine-${kind}${after ? ' cm-gitLine-after' : ''}`;
+    }
+    eq(other) { return other.kind === this.kind && other.after === this.after; }
+  }
+  const markers = {
+    added: new ChangeMarker('added'),
+    modified: new ChangeMarker('modified'),
+    deleted: new ChangeMarker('deleted'),
+    deletedAfter: new ChangeMarker('deleted', true),
+  };
+
+  const setMarks = StateEffect.define();
+
+  function build(doc, marks) {
+    const builder = new RangeSetBuilder();
+    for (const mark of marks) {
+      const marker = mark.kind === 'deleted' ? (mark.after ? markers.deletedAfter : markers.deleted) : markers[mark.kind];
+      if (!marker) continue;
+      const last = Math.min(mark.to, doc.lines);
+      for (let n = Math.max(1, mark.from); n <= last; n++) {
+        const at = doc.line(n).from;
+        builder.add(at, at, marker);
+      }
+    }
+    return builder.finish();
+  }
+
+  const field = StateField.define({
+    create: () => RangeSet.empty,
+    update(value, tr) {
+      for (const effect of tr.effects) if (effect.is(setMarks)) return build(tr.state.doc, effect.value);
+      return tr.docChanged ? value.map(tr.changes) : value;
+    },
+  });
+
+  const column = gutter({ class: 'cm-gitGutter', markers: (view) => view.state.field(field) });
+
+  return {
+    /** The column and the marks it shows (none until an effect brings them). For the view's git compartment. */
+    extension: [field, column],
+
+    /**
+     * Show these marks.
+     * @param {{ from: number, to: number, kind: 'added' | 'modified' | 'deleted', after?: boolean }[]} marks
+     *   lines of the document (editor-git-logic.js: gitMarks)
+     */
+    marks: (marks) => setMarks.of(marks || []),
+
+    /** Whether a state has the column. */
+    has: (state) => state.field(field, false) !== undefined,
+
+    /** The kinds of the marks a state shows, by line number: for a test, or a count. */
+    lines(state) {
+      const found = new Map();
+      const set = state.field(field, false);
+      if (!set) return found;
+      for (let cursor = set.iter(); cursor.value; cursor.next()) found.set(state.doc.lineAt(cursor.from).number, cursor.value.kind);
+      return found;
+    },
+
+    /** Call `use(position, kind)` for each mark between two document positions (the minimap draws them). */
+    between(state, from, to, use) {
+      const set = state.field(field, false);
+      if (set) set.between(from, to, (at, _end, marker) => { use(at, marker.kind); });
+    },
+  };
+}

package/neural-interface/public/shared/editor/editor-languages.js

@@ -0,0 +1,156 @@
+// ═══════════════════════════════════════════
+// SynaBun Neural Interface — Code editor: which language a file is
+// ═══════════════════════════════════════════
+//
+// File name → the language it is highlighted as, and the word the status bar
+// shows. A language is named the way @codemirror/language-data names it; the
+// view looks the name up in the vendored bundle and loads its chunk. This table
+// only holds what language-data does not know by itself: dotfiles, lockfiles
+// and a few extensions. For every other name the view asks language-data.
+// No DOM and no imports: loaded by `node --test` as it is.
+
+const PROPERTIES = 'Properties files';
+
+// Exact file names, lower case.
+const BY_NAME = {
+  // shell start-up files
+  '.bashrc': { language: 'Shell' },
+  '.bash_profile': { language: 'Shell' },
+  '.bash_aliases': { language: 'Shell' },
+  '.bash_logout': { language: 'Shell' },
+  '.profile': { language: 'Shell' },
+  '.zshrc': { language: 'Shell' },
+  '.zshenv': { language: 'Shell' },
+  '.zprofile': { language: 'Shell' },
+  '.zlogin': { language: 'Shell' },
+  '.envrc': { language: 'Shell' },
+  // key = value files
+  '.npmrc': { language: PROPERTIES, label: 'Properties' },
+  '.yarnrc': { language: PROPERTIES, label: 'Properties' },
+  '.editorconfig': { language: PROPERTIES, label: 'EditorConfig' },
+  '.gitconfig': { language: PROPERTIES, label: 'Git Config' },
+  '.gitmodules': { language: PROPERTIES, label: 'Git Config' },
+  '.netrc': { language: null, label: 'Plain Text' },
+  // JSON under another name
+  '.babelrc': { language: 'JSON' },
+  '.eslintrc': { language: 'JSON' },
+  '.prettierrc': { language: 'JSON' },
+  '.stylelintrc': { language: 'JSON' },
+  '.swcrc': { language: 'JSON' },
+  '.watchmanconfig': { language: 'JSON' },
+  // lockfiles
+  'package-lock.json': { language: 'JSON' },
+  'npm-shrinkwrap.json': { language: 'JSON' },
+  'composer.lock': { language: 'JSON' },
+  'pipfile.lock': { language: 'JSON' },
+  'flake.lock': { language: 'JSON' },
+  'bun.lock': { language: 'JSON' },
+  'deno.lock': { language: 'JSON' },
+  'yarn.lock': { language: 'YAML' },
+  'pnpm-lock.yaml': { language: 'YAML' },
+  'cargo.lock': { language: 'TOML' },
+  'poetry.lock': { language: 'TOML' },
+  'uv.lock': { language: 'TOML' },
+  'pdm.lock': { language: 'TOML' },
+  'gemfile.lock': { language: null, label: 'Plain Text' },
+  'go.sum': { language: null, label: 'Plain Text' },
+  // build files
+  'makefile': { language: 'Shell', label: 'Makefile' },
+  'gnumakefile': { language: 'Shell', label: 'Makefile' },
+  'containerfile': { language: 'Dockerfile' },
+  'gemfile': { language: 'Ruby' },
+  'rakefile': { language: 'Ruby' },
+  'pipfile': { language: 'TOML' },
+};
+
+// File name patterns, first match wins.
+const BY_PATTERN = [
+  { test: /^\.env(\.|$)/i, language: PROPERTIES, label: 'ENV' },
+  { test: /\.env$/i, language: PROPERTIES, label: 'ENV' },
+  { test: /^\.[\w-]*ignore$/i, language: 'Shell', label: 'Ignore' },
+  { test: /^dockerfile(\.|$)/i, language: 'Dockerfile' },
+  { test: /\.dockerfile$/i, language: 'Dockerfile' },
+  { test: /^\.(eslintrc|prettierrc|stylelintrc)\.json[c5]?$/i, language: 'JSON' },
+];
+
+// Extensions language-data has no entry for, lower case.
+const BY_EXTENSION = {
+  jsonc: { language: 'JSON' },
+  json5: { language: 'JSON' },
+  jsonl: { language: 'JSON' },
+  ndjson: { language: 'JSON' },
+  webmanifest: { language: 'JSON' },
+  mdx: { language: 'Markdown' },
+  mdc: { language: 'Markdown' },
+  svelte: { language: 'HTML', label: 'Svelte' },
+  astro: { language: 'HTML', label: 'Astro' },
+  xhtml: { language: 'HTML' },
+  plist: { language: 'XML' },
+  zsh: { language: 'Shell' },
+  fish: { language: 'Shell' },
+  command: { language: 'Shell' },
+  cfg: { language: PROPERTIES, label: 'Properties' },
+  conf: { language: PROPERTIES, label: 'Properties' },
+  ini: { language: PROPERTIES, label: 'INI' },
+  properties: { language: PROPERTIES, label: 'Properties' },
+  diff: { language: 'diff', label: 'Diff' },
+  patch: { language: 'diff', label: 'Diff' },
+};
+
+/** The last path segment of `path`, whichever separator it uses. */
+export function baseName(path) {
+  const s = String(path ?? '');
+  const cut = Math.max(s.lastIndexOf('/'), s.lastIndexOf('\\'));
+  return cut === -1 ? s : s.slice(cut + 1);
+}
+
+/** The extension of a file name, lower case, without the dot. '' for a name that has none (a dotfile has none). */
+export function extensionOf(fileName) {
+  const name = baseName(fileName);
+  const dot = name.lastIndexOf('.');
+  return dot > 0 ? name.slice(dot + 1).toLowerCase() : '';
+}
+
+/**
+ * What this table says about a file name.
+ * @returns {{ language: string | null, label: string | null, known: boolean }}
+ *   `known: false` → the table has no entry: ask language-data by file name.
+ *   `language: null` with `known: true` → plain text, on purpose.
+ *   `label: null` → show the language's own name.
+ */
+export function resolveLanguage(fileName) {
+  const name = baseName(fileName);
+  const lower = name.toLowerCase();
+  const hit = BY_NAME[lower]
+    || BY_PATTERN.find((p) => p.test.test(name))
+    || BY_EXTENSION[extensionOf(name)];
+  if (!hit) return { language: null, label: null, known: false };
+  return { language: hit.language ?? null, label: hit.label ?? null, known: true };
+}
+
+/**
+ * The word the status bar shows for a file.
+ * @param {string} fileName
+ * @param {string | null} languageName the name of the language that was found for it (language-data's), if any
+ * @returns {string | null} null → plain text: the caller shows its own translated words
+ */
+export function languageLabel(fileName, languageName) {
+  const { label, known, language } = resolveLanguage(fileName);
+  if (label) return label === 'Plain Text' ? null : label;
+  if (languageName) return languageName;
+  if (known && language) return language;
+  const ext = extensionOf(fileName);
+  return ext ? ext.toUpperCase() : null;
+}
+
+/** Whether a file is Markdown (it gets the Raw / Preview switch). */
+export function isMarkdownFile(fileName) {
+  const ext = extensionOf(fileName);
+  return ext === 'md' || ext === 'markdown' || ext === 'mkd' || ext === 'mdx' || ext === 'mdc';
+}
+
+/** Every language name this table can ask for (tests check each one exists in the bundle). */
+export function namedLanguages() {
+  const all = [...Object.values(BY_NAME), ...BY_PATTERN, ...Object.values(BY_EXTENSION)];
+  return [...new Set(all.map((e) => e.language).filter(Boolean))].sort();
+}