@vibefield/rosetta-room 0.0.0-stage → 0.1.0

package/dist/components/file-viewer/minimap/raster.js

@@ -0,0 +1,122 @@
+// The minimap's one hot pass: syntax-coloured blocks written directly into
+// a pane-sized pixel buffer. It deliberately knows nothing about Canvas or
+// the DOM, so node:test can exercise the exact renderer without a browser.
+import { MINIMAP_ROW_DEVICE_PIXELS } from "./layout.js";
+export const MINIMAP_CHARACTER_DEVICE_PIXELS = 1;
+export const MINIMAP_CHARACTER_HEIGHT_DEVICE_PIXELS = 2;
+export const MINIMAP_LEFT_GUTTER_DEVICE_PIXELS = 2;
+export const MINIMAP_MAX_COLUMNS = 96;
+const endianProbe = new Uint32Array([0x01020304]);
+const LITTLE_ENDIAN = new Uint8Array(endianProbe.buffer)[0] === 0x04;
+const COMBINING_MARK = /\p{Mark}/u;
+export function packRgba(red, green, blue, alpha = 255) {
+    const r = red & 0xff;
+    const g = green & 0xff;
+    const b = blue & 0xff;
+    const a = alpha & 0xff;
+    return LITTLE_ENDIAN
+        ? ((a << 24) | (b << 16) | (g << 8) | r) >>> 0
+        : ((r << 24) | (g << 16) | (b << 8) | a) >>> 0;
+}
+/** A compact East Asian Width predicate. Unlike `codePoint > 0xff`, this
+ * leaves Greek, Cyrillic, Hebrew, combining marks, and ordinary symbols at
+ * their actual monospace width. */
+function isFullWidthCodePoint(point) {
+    if (point < 0x1100)
+        return false;
+    return (point <= 0x115f ||
+        point === 0x2329 ||
+        point === 0x232a ||
+        (point >= 0x2e80 && point <= 0x303e) ||
+        (point >= 0x3040 && point <= 0xa4cf) ||
+        (point >= 0xac00 && point <= 0xd7a3) ||
+        (point >= 0xf900 && point <= 0xfaff) ||
+        (point >= 0xfe10 && point <= 0xfe19) ||
+        (point >= 0xfe30 && point <= 0xfe6f) ||
+        (point >= 0xff00 && point <= 0xff60) ||
+        (point >= 0xffe0 && point <= 0xffe6) ||
+        (point >= 0x1b000 && point <= 0x1b001) ||
+        (point >= 0x1f200 && point <= 0x1f251) ||
+        (point >= 0x20000 && point <= 0x3fffd));
+}
+function characterColumns(character) {
+    const point = character.codePointAt(0) ?? 0;
+    if (point === 0x200d || COMBINING_MARK.test(character))
+        return 0;
+    return isFullWidthCodePoint(point) ? 2 : 1;
+}
+function isGap(character) {
+    return (character === " " ||
+        character === "\t" ||
+        character === "\r" ||
+        character === "\n" ||
+        character === "\u00a0");
+}
+function paintRun(pixels, width, height, xFrom, xTo, y, color) {
+    const from = Math.max(0, Math.min(width, xFrom));
+    const to = Math.max(from, Math.min(width, xTo));
+    if (from === to)
+        return;
+    const bottom = Math.min(height, y + MINIMAP_CHARACTER_HEIGHT_DEVICE_PIXELS);
+    for (let pixelY = y; pixelY < bottom; pixelY += 1) {
+        pixels.fill(color, pixelY * width + from, pixelY * width + to);
+    }
+}
+function rasterLine(pixels, width, height, y, line, tabColumns, palette) {
+    const maxX = Math.min(width, MINIMAP_LEFT_GUTTER_DEVICE_PIXELS +
+        MINIMAP_MAX_COLUMNS * MINIMAP_CHARACTER_DEVICE_PIXELS);
+    const tabs = Math.max(1, Math.floor(tabColumns));
+    let column = 0;
+    let x = MINIMAP_LEFT_GUTTER_DEVICE_PIXELS;
+    for (const token of line) {
+        if (x >= maxX)
+            return;
+        let runStart = -1;
+        const flush = () => {
+            if (runStart === -1)
+                return;
+            paintRun(pixels, width, height, runStart, Math.min(x, maxX), y, palette.token[token.kind]);
+            runStart = -1;
+        };
+        for (const character of token.text) {
+            if (isGap(character)) {
+                flush();
+                const advance = character === "\t" ? tabs - (column % tabs) : characterColumns(character);
+                column += advance;
+                x += advance * MINIMAP_CHARACTER_DEVICE_PIXELS;
+                if (x >= maxX)
+                    return;
+                continue;
+            }
+            const advance = characterColumns(character);
+            if (advance === 0)
+                continue;
+            if (runStart === -1)
+                runStart = x;
+            column += advance;
+            x += advance * MINIMAP_CHARACTER_DEVICE_PIXELS;
+            if (x >= maxX) {
+                flush();
+                return;
+            }
+        }
+        flush();
+    }
+}
+export function rasterizeMinimap(args) {
+    const width = Math.max(0, Math.floor(args.width));
+    const height = Math.max(0, Math.floor(args.height));
+    const pixelCount = width * height;
+    if (width === 0 || height === 0 || args.pixels.length < pixelCount)
+        return;
+    args.pixels.fill(args.palette.background, 0, pixelCount);
+    const availableRows = Math.floor(height / MINIMAP_ROW_DEVICE_PIXELS);
+    const rowCount = Math.min(availableRows, args.lineIndexes === null ? args.lines.length : args.lineIndexes.length);
+    for (let row = 0; row < rowCount; row += 1) {
+        const lineIndex = args.lineIndexes === null ? row : args.lineIndexes[row];
+        const line = args.lines[lineIndex];
+        if (line === undefined)
+            continue;
+        rasterLine(args.pixels, width, height, row * MINIMAP_ROW_DEVICE_PIXELS, line, args.tabColumns, args.palette);
+    }
+}

package/dist/components/file-viewer/registry.d.ts

@@ -0,0 +1,25 @@
+import type { FileKind } from "./types.js";
+export declare const BINARY_KIND: FileKind;
+/**
+ * The kind for a change rather than a file.
+ *
+ * Chosen by the CALLER, not by the name: the same `main.rs` is a source file
+ * when the tree opens it and a diff when the git column does, and only the
+ * caller knows which act it is serving.
+ */
+export declare function diffKind(name: string): FileKind;
+/** What a file name says the file is. Extension only — see `syntax/languages`
+ * for why the bytes get no vote here. */
+export declare function resolveKind(name: string): FileKind;
+/** Only for a source-proven image slot; extensionless tool captures need the
+ * same format hint whether opened from a loaded tile or reached with Next. */
+export declare function imageKind(name: string, bytes?: Uint8Array): FileKind;
+/**
+ * Does this look like something no one can read as text?
+ *
+ * The test git has used for decades: a NUL byte in the first pages. It is a
+ * heuristic and it is named as one — but it is the heuristic that is right
+ * about real files, and the alternative is showing a reader a screenful of
+ * replacement characters and calling it a document.
+ */
+export declare function looksBinary(bytes: Uint8Array): boolean;

package/dist/components/file-viewer/registry.js

@@ -0,0 +1,182 @@
+// Which view a file gets, and what the dialog is allowed to do with it.
+//
+// One table, read once per open. Adding a format is an entry here — never a
+// branch inside a view, and never a condition in the dialog, which is the
+// point of the whole arrangement: the dialog knows there are views, and it
+// does not know what any of them are.
+import { extensionOf, languageFor, PLAIN_TEXT } from "./syntax/index.js";
+import { BinaryView } from "./views/BinaryView.js";
+import { CodeView } from "./views/CodeView.js";
+import { DiffView } from "./views/DiffView.js";
+import { ImageView, IMAGE_MODES } from "./views/ImageView.js";
+import { MarkdownView, MARKDOWN_MODES } from "./views/MarkdownView.js";
+import { SvgView, SVG_MODES } from "./views/SvgView.js";
+import { imageMediaTypeFromBytes } from "../../lib/image-media.js";
+const KB = 1024;
+const MB = 1024 * KB;
+/** Source is read whole so the highlighter can see block comments across the
+ * file. Two megabytes of it is a very large source file and a fast read; past
+ * that the honest move is to say the number rather than to freeze. */
+const TEXT_LIMIT = 2 * MB;
+/** An image is decoded by the compositor, not by us, so it can be larger. */
+const IMAGE_LIMIT = 32 * MB;
+/** A hex dump shows its first pages, but the read still crosses a port. */
+const BINARY_LIMIT = 8 * MB;
+const CODE = {
+    id: "code",
+    payload: "text",
+    maxBytes: TEXT_LIMIT,
+    actions: ["copy-path"],
+    Body: CodeView,
+};
+/** HTML is shown as source and never rendered. A page in a worktree is
+ * untrusted markup with scripts in it, and this room has a preload bridge; the
+ * place that can safely run it is a browser, which is what the extra act
+ * offers. That the safe answer and the useful one agree here is luck worth
+ * taking. */
+const HTML = {
+    ...CODE,
+    id: "html",
+    actions: ["copy-path", "open-in-browser"],
+};
+const MARKDOWN = {
+    id: "markdown",
+    payload: "text",
+    maxBytes: TEXT_LIMIT,
+    modes: MARKDOWN_MODES,
+    actions: ["copy-path"],
+    Body: MarkdownView,
+};
+const IMAGE = {
+    id: "image",
+    payload: "bytes",
+    maxBytes: IMAGE_LIMIT,
+    modes: IMAGE_MODES,
+    actions: ["copy-path"],
+    Body: ImageView,
+};
+/** SVG takes `text` as well as bytes, because its source half is the same
+ * code view every other file gets. */
+const SVG = {
+    id: "svg",
+    payload: "text",
+    maxBytes: TEXT_LIMIT,
+    modes: SVG_MODES,
+    actions: ["copy-path", "open-in-browser"],
+    Body: SvgView,
+};
+/** A change, not a file. Its limit is `Infinity` because git bounds its own
+ * output host-side and a diff's size has nothing to do with the file's. */
+const DIFF = {
+    id: "diff",
+    payload: "compare",
+    maxBytes: Number.POSITIVE_INFINITY,
+    actions: ["copy-path"],
+    Body: DiffView,
+};
+const BINARY = {
+    id: "binary",
+    payload: "bytes",
+    maxBytes: BINARY_LIMIT,
+    actions: ["copy-path"],
+    Body: BinaryView,
+};
+const IMAGE_TYPES = new Map([
+    ["png", "image/png"],
+    ["jpg", "image/jpeg"],
+    ["jpeg", "image/jpeg"],
+    ["gif", "image/gif"],
+    ["webp", "image/webp"],
+    ["avif", "image/avif"],
+    ["bmp", "image/bmp"],
+    ["ico", "image/x-icon"],
+    ["apng", "image/apng"],
+]);
+/** Extensions worth refusing to decode as text before reading a byte. An
+ * unknown extension is NOT on this list: it is read as text and downgraded if
+ * the bytes disagree, because most unfamiliar extensions in a repository are
+ * somebody's config file. */
+const BINARY_EXTENSIONS = new Set([
+    "zip", "gz", "tgz", "bz2", "xz", "zst", "7z", "rar", "tar", "jar", "war",
+    "pdf", "doc", "docx", "xls", "xlsx", "ppt", "pptx", "key", "numbers", "pages",
+    "so", "dylib", "dll", "a", "o", "obj", "exe", "bin", "wasm", "node", "rlib", "pdb",
+    "woff", "woff2", "ttf", "otf", "eot",
+    "mp3", "mp4", "m4a", "wav", "aiff", "flac", "ogg", "webm", "mov", "avi", "mkv",
+    "db", "sqlite", "sqlite3", "rdb", "pack", "idx", "class", "pyc", "pyo",
+    "psd", "sketch", "fig", "ai", "heic", "tiff", "tif", "dmg", "iso", "img",
+]);
+export const BINARY_KIND = {
+    viewer: BINARY,
+    label: "Binary",
+    language: null,
+    mime: null,
+};
+/** Text with no language behind it: read, shown, nothing claimed about it. */
+const UNKNOWN_TEXT_KIND = {
+    viewer: CODE,
+    label: "Text",
+    language: PLAIN_TEXT,
+    mime: null,
+};
+/**
+ * The kind for a change rather than a file.
+ *
+ * Chosen by the CALLER, not by the name: the same `main.rs` is a source file
+ * when the tree opens it and a diff when the git column does, and only the
+ * caller knows which act it is serving.
+ */
+export function diffKind(name) {
+    return { viewer: DIFF, label: "Diff", language: languageFor(name), mime: null };
+}
+/** What a file name says the file is. Extension only — see `syntax/languages`
+ * for why the bytes get no vote here. */
+export function resolveKind(name) {
+    const extension = extensionOf(name);
+    if (extension === "svg") {
+        return { viewer: SVG, label: "SVG", language: languageFor(name), mime: "image/svg+xml" };
+    }
+    const mime = IMAGE_TYPES.get(extension);
+    if (mime !== undefined) {
+        return { viewer: IMAGE, label: extension.toUpperCase(), language: null, mime };
+    }
+    if (BINARY_EXTENSIONS.has(extension)) {
+        return { ...BINARY_KIND, label: extension === "" ? "Binary" : extension.toUpperCase() };
+    }
+    const language = languageFor(name);
+    if (language === null)
+        return UNKNOWN_TEXT_KIND;
+    if (language.id === "markdown") {
+        return { viewer: MARKDOWN, label: language.label, language, mime: null };
+    }
+    if (language.id === "html") {
+        return { viewer: HTML, label: language.label, language, mime: "text/html" };
+    }
+    return { viewer: CODE, label: language.label, language, mime: null };
+}
+/** Only for a source-proven image slot; extensionless tool captures need the
+ * same format hint whether opened from a loaded tile or reached with Next. */
+export function imageKind(name, bytes) {
+    const kind = resolveKind(name);
+    if (kind.viewer.id === "image" || kind.viewer.id === "svg")
+        return kind;
+    const mime = bytes ? imageMediaTypeFromBytes(bytes) : null;
+    if (mime === "image/svg+xml")
+        return resolveKind("image.svg");
+    return { viewer: IMAGE, label: mime?.split("/")[1].toUpperCase() ?? "Image", language: null, mime };
+}
+/**
+ * Does this look like something no one can read as text?
+ *
+ * The test git has used for decades: a NUL byte in the first pages. It is a
+ * heuristic and it is named as one — but it is the heuristic that is right
+ * about real files, and the alternative is showing a reader a screenful of
+ * replacement characters and calling it a document.
+ */
+export function looksBinary(bytes) {
+    const end = Math.min(bytes.length, 8 * KB);
+    for (let at = 0; at < end; at += 1) {
+        if (bytes[at] === 0)
+            return true;
+    }
+    return false;
+}

package/dist/components/file-viewer/syntax/grammars.d.ts

@@ -0,0 +1,16 @@
+import type { Grammar } from "./types.js";
+export declare const typescript: Grammar;
+export declare const rust: Grammar;
+export declare const python: Grammar;
+export declare const go: Grammar;
+export declare const c: Grammar;
+export declare const java: Grammar;
+export declare const swift: Grammar;
+export declare const ruby: Grammar;
+export declare const php: Grammar;
+export declare const shell: Grammar;
+export declare const sql: Grammar;
+export declare const lua: Grammar;
+export declare const json: Grammar;
+/** Text with no grammar at all: no comments, no keywords, nothing claimed. */
+export declare const plain: Grammar;

package/dist/components/file-viewer/syntax/grammars.js

@@ -0,0 +1,221 @@
+// The language tables. Data, not code: adding a language is an entry here,
+// never a new branch in the tokenizer.
+//
+// The keyword lists are deliberately the language's OWN words — its
+// declarations, control flow and modifiers — not its standard library. A
+// highlighter that paints every library name it has heard of is making a
+// claim about the code it cannot support, and it goes stale the first time
+// the library does.
+const words = (list) => new Set(list.trim().split(/\s+/));
+/** `"…"` and `'…'`, backslash-escaped, one line each. */
+const QUOTED = [
+    { open: '"', escape: "\\" },
+    { open: "'", escape: "\\" },
+];
+const SHARED_CONSTANTS = words("true false null undefined nil None True False NULL nullptr");
+/* ── the C family ──────────────────────────────────────────────────────── */
+export const typescript = {
+    lineComments: ["//"],
+    blockComments: [["/*", "*/"]],
+    strings: [{ open: "`", multiline: true, escape: "\\" }, ...QUOTED],
+    keywords: words(`
+    abstract as async await break case catch class const continue debugger declare default
+    delete do else enum export extends finally for from function get if implements import in
+    infer instanceof interface is keyof let namespace new of override package private protected
+    public readonly require return satisfies set static super switch this throw try type typeof
+    var void while with yield
+  `),
+    constants: SHARED_CONSTANTS,
+    types: words(`
+    any bigint boolean never number object string symbol unknown void
+    Array Promise Record Map Set ReadonlyArray Partial Readonly
+  `),
+    capitalIsType: true,
+    annotation: /@[A-Za-z_][A-Za-z0-9_.]*/y,
+    regexLiterals: true,
+};
+export const rust = {
+    lineComments: ["//"],
+    blockComments: [["/*", "*/"]],
+    // Rust string literals span lines, and `'a` is a lifetime rather than the
+    // opening of a character literal.
+    strings: [{ open: '"', multiline: true, escape: "\\" }, { open: "'", escape: "\\" }],
+    lifetimeQuote: true,
+    keywords: words(`
+    as async await box break const continue crate dyn else enum extern fn for if impl in let
+    loop match mod move mut pub ref return self Self static struct super trait type union
+    unsafe use where while
+  `),
+    constants: words("true false None Some Ok Err"),
+    types: words(`
+    bool char f32 f64 i8 i16 i32 i64 i128 isize str u8 u16 u32 u64 u128 usize
+    String Vec Option Result Box Rc Arc HashMap BTreeMap
+  `),
+    capitalIsType: true,
+};
+export const python = {
+    lineComments: ["#"],
+    // Docstrings first: `"""` must be tried before `"`, or every docstring
+    // opens and closes on its own first two characters.
+    strings: [
+        { open: '"""', multiline: true, escape: "\\" },
+        { open: "'''", multiline: true, escape: "\\" },
+        ...QUOTED,
+    ],
+    keywords: words(`
+    and as assert async await break class continue def del elif else except finally for from
+    global if import in is lambda match nonlocal not or pass raise return try while with yield
+  `),
+    constants: words("True False None NotImplemented Ellipsis self cls"),
+    types: words("bool bytes dict float frozenset int list object set str tuple type"),
+    capitalIsType: true,
+    annotation: /@[A-Za-z_][A-Za-z0-9_.]*/y,
+};
+export const go = {
+    lineComments: ["//"],
+    blockComments: [["/*", "*/"]],
+    strings: [{ open: "`", multiline: true }, ...QUOTED],
+    keywords: words(`
+    break case chan const continue default defer else fallthrough for func go goto if import
+    interface map package range return select struct switch type var
+  `),
+    constants: words("true false nil iota"),
+    types: words(`
+    bool byte complex64 complex128 error float32 float64 int int8 int16 int32 int64 rune string
+    uint uint8 uint16 uint32 uint64 uintptr any
+  `),
+    capitalIsType: true,
+};
+export const c = {
+    lineComments: ["//"],
+    blockComments: [["/*", "*/"]],
+    strings: QUOTED,
+    // `#include`, `#define` — the preprocessor is a second language spoken in
+    // the first one's file, and it earns its own mark.
+    annotation: /#[ \t]*[a-z]+/y,
+    keywords: words(`
+    alignas alignof auto break case catch class const consteval constexpr continue co_await
+    co_return co_yield decltype default delete do else enum explicit export extern final for
+    friend goto if inline mutable namespace new noexcept operator override private protected
+    public register return signed sizeof static static_assert struct switch template this
+    thread_local throw try typedef typename union unsigned using virtual volatile while
+  `),
+    constants: words("true false NULL nullptr"),
+    types: words("bool char double float int long short size_t ssize_t void wchar_t uint8_t uint16_t uint32_t uint64_t int8_t int16_t int32_t int64_t"),
+    capitalIsType: true,
+};
+export const java = {
+    lineComments: ["//"],
+    blockComments: [["/*", "*/"]],
+    strings: QUOTED,
+    annotation: /@[A-Za-z_][A-Za-z0-9_.]*/y,
+    keywords: words(`
+    abstract as assert break by case catch class companion const constructor continue crossinline
+    data default do else enum extends external final finally for fun goto if implements import
+    in infix init inline instanceof interface internal is lateinit native new object open
+    operator out override package private protected public reified return sealed static
+    strictfp super suspend switch synchronized tailrec this throw throws transient try typealias
+    val var vararg volatile when while
+  `),
+    constants: words("true false null this super it"),
+    types: words(`
+    boolean byte char double float int long short void var
+    Any Boolean Byte Char Double Float Int Long Nothing Short String Unit
+  `),
+    capitalIsType: true,
+};
+export const swift = {
+    lineComments: ["//"],
+    blockComments: [["/*", "*/"]],
+    strings: [{ open: '"""', multiline: true, escape: "\\" }, { open: '"', escape: "\\" }],
+    annotation: /@[A-Za-z_][A-Za-z0-9_]*/y,
+    keywords: words(`
+    actor as associatedtype async await break case catch class continue convenience default
+    defer deinit didSet do else enum extension fallthrough fileprivate final for func get guard
+    if import in indirect infix init inout internal is lazy let mutating nonisolated open
+    operator private protocol public repeat required rethrows return self set some static
+    struct subscript super switch throw throws try typealias var weak where while willSet
+  `),
+    constants: words("true false nil"),
+    types: words("Any Array Bool Character Data Dictionary Double Float Int Optional Result Set String UInt Void"),
+    capitalIsType: true,
+};
+export const ruby = {
+    lineComments: ["#"],
+    strings: QUOTED,
+    variableSigils: ["@@", "@", "$"],
+    keywords: words(`
+    alias and begin break case class def defined? do else elsif end ensure for if in module
+    next not or redo rescue retry return self super then unless until when while yield
+  `),
+    constants: words("true false nil __FILE__ __LINE__"),
+    capitalIsType: true,
+};
+export const php = {
+    lineComments: ["//", "#"],
+    blockComments: [["/*", "*/"]],
+    strings: QUOTED,
+    variableSigils: ["$"],
+    keywords: words(`
+    abstract and array as break callable case catch class clone const continue declare default
+    do echo else elseif empty enddeclare endfor endforeach endif endswitch endwhile enum extends
+    final finally fn for foreach function global goto if implements include include_once
+    instanceof insteadof interface isset list match namespace new or print private protected
+    public readonly require require_once return static switch throw trait try unset use var
+    while xor yield
+  `),
+    constants: words("true false null TRUE FALSE NULL"),
+    capitalIsType: true,
+};
+export const shell = {
+    lineComments: ["#"],
+    strings: [{ open: '"', multiline: true, escape: "\\" }, { open: "'", multiline: true }],
+    variableSigils: ["$"],
+    keywords: words(`
+    alias break case cd continue do done echo elif else esac exec exit export fi for function
+    if in local return set shift source then time trap unset until while
+  `),
+    constants: words("true false"),
+};
+export const sql = {
+    lineComments: ["--"],
+    blockComments: [["/*", "*/"]],
+    // SQL escapes a quote by doubling it, which a backslash rule gets wrong;
+    // no escape character is the honest setting.
+    strings: [{ open: "'" }, { open: '"' }],
+    keywords: words(`
+    ADD ALL ALTER AND AS ASC AUTOINCREMENT BEGIN BETWEEN BY CASCADE CASE CHECK COLLATE COLUMN
+    COMMIT CONFLICT CONSTRAINT CREATE CROSS DEFAULT DELETE DESC DISTINCT DROP ELSE END EXCEPT
+    EXISTS FOREIGN FROM FULL GROUP HAVING IF IN INDEX INNER INSERT INTERSECT INTO IS JOIN KEY
+    LEFT LIKE LIMIT NOT NULL OFFSET ON OR ORDER OUTER PRAGMA PRIMARY REFERENCES REPLACE RETURNING
+    RIGHT ROLLBACK SELECT SET TABLE THEN TRANSACTION UNION UNIQUE UPDATE USING VACUUM VALUES
+    VIEW WHEN WHERE WITH
+    add all alter and as asc begin between by case check collate column commit constraint create
+    cross default delete desc distinct drop else end except exists foreign from full group having
+    if in index inner insert intersect into is join key left like limit not null offset on or
+    order outer pragma primary references replace returning right rollback select set table then
+    transaction union unique update using values view when where with
+  `),
+    constants: words("TRUE FALSE NULL true false null"),
+};
+export const lua = {
+    lineComments: ["--"],
+    blockComments: [["--[[", "]]"]],
+    strings: [{ open: "[[", close: "]]", multiline: true }, ...QUOTED],
+    keywords: words(`
+    and break do else elseif end for function goto if in local not or repeat return then until
+    while
+  `),
+    constants: words("true false nil self"),
+};
+export const json = {
+    // JSONC and every `tsconfig.json` in the wild. Plain JSON has no comments,
+    // and a highlighter that shows one anyway is showing the file it has.
+    lineComments: ["//"],
+    blockComments: [["/*", "*/"]],
+    strings: [{ open: '"', escape: "\\" }],
+    constants: words("true false null"),
+    propertyBeforeColon: true,
+};
+/** Text with no grammar at all: no comments, no keywords, nothing claimed. */
+export const plain = {};

package/dist/components/file-viewer/syntax/index.d.ts

@@ -0,0 +1,8 @@
+import type { Language } from "./languages.js";
+import type { TokenLine } from "./types.js";
+export { extensionOf, languageFor, PLAIN_TEXT } from "./languages.js";
+export type { Language } from "./languages.js";
+export type { Token, TokenKind, TokenLine } from "./types.js";
+/** Tokenize `text` and cut it into lines. Pure and synchronous: a viewer that
+ * has the bytes has the highlighting, with no second render to wait for. */
+export declare function highlight(text: string, language: Language): readonly TokenLine[];

package/dist/components/file-viewer/syntax/index.js

@@ -0,0 +1,9 @@
+// The highlighter's whole public surface: a language, and one function that
+// turns text into lines of tokens.
+import { splitLines } from "./tokenize.js";
+export { extensionOf, languageFor, PLAIN_TEXT } from "./languages.js";
+/** Tokenize `text` and cut it into lines. Pure and synchronous: a viewer that
+ * has the bytes has the highlighting, with no second render to wait for. */
+export function highlight(text, language) {
+    return splitLines(language.tokenize(text));
+}

package/dist/components/file-viewer/syntax/languages.d.ts

@@ -0,0 +1,14 @@
+import type { Token } from "./types.js";
+export interface Language {
+    readonly id: string;
+    /** What the kind chip says: the language's own name, as its users spell it. */
+    readonly label: string;
+    readonly tokenize: (text: string) => readonly Token[];
+}
+export declare const PLAIN_TEXT: Language;
+/** The last dot-segment of a name, lowercased. `""` when there is no dot. */
+export declare function extensionOf(name: string): string;
+/** The language a file name claims, or `null` when no entry matches — which
+ * is a different answer from "plain text", and the caller decides what to do
+ * with the difference. */
+export declare function languageFor(name: string): Language | null;