@nibapp/ui 0.0.0-stage → 0.1.0

package/dist/lib/patch.js

@@ -0,0 +1,344 @@
+const HUNK_HEADER = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/u;
+const ANY_HUNK_HEADER = new RegExp(HUNK_HEADER.source, "mu");
+const GIT_HEADER = "diff --git ";
+const NO_NEWLINE = "\";
+/** Whether `text` holds at least one `@@ -a,b +c,d @@` hunk. */
+export function isUnifiedDiff(text) {
+    return ANY_HUNK_HEADER.test(text);
+}
+/* ------------------------------------------------------------------------------------------ */
+/* Paths                                                                                      */
+/* ------------------------------------------------------------------------------------------ */
+const C_ESCAPES = {
+    a: "\u0007",
+    b: "\b",
+    f: "\f",
+    n: "\n",
+    r: "\r",
+    t: "\t",
+    v: "\v",
+    "\\": "\\",
+    '"': '"',
+};
+/**
+ * Git C-quotes paths with special characters (`"a/caf\303\251.txt"`). Octal escapes are UTF-8
+ * bytes, so they are collected and decoded together; anything else is written raw (`core.quotePath`
+ * off), taken a code point at a time so a character outside the BMP stays whole.
+ */
+export function unquoteGitPath(raw) {
+    if (!(raw.length >= 2 && raw.startsWith('"') && raw.endsWith('"'))) {
+        return raw;
+    }
+    const body = raw.slice(1, -1);
+    const bytes = [];
+    const encoder = new TextEncoder();
+    for (let i = 0, point = body.codePointAt(0); point !== undefined; point = body.codePointAt(i)) {
+        const char = String.fromCodePoint(point);
+        if (char !== "\\") {
+            bytes.push(...encoder.encode(char));
+            i += char.length;
+            continue;
+        }
+        const octal = /^[0-7]{3}/u.exec(body.slice(i + 1, i + 4));
+        if (octal !== null) {
+            bytes.push(Number.parseInt(octal[0], 8));
+            i += 4;
+            continue;
+        }
+        const next = body.charAt(i + 1);
+        bytes.push(...encoder.encode(C_ESCAPES[next] ?? next));
+        i += 2;
+    }
+    return new TextDecoder().decode(new Uint8Array(bytes));
+}
+/**
+ * `a/src/x.ts` → `src/x.ts`; `/dev/null` → undefined. A tab ends the path: `diff -u` puts its
+ * timestamp after one.
+ */
+function stripSide(raw) {
+    const path = unquoteGitPath(raw.trim().replace(/\t.*$/u, ""));
+    if (path === "/dev/null") {
+        return undefined;
+    }
+    return path.replace(/^[ab]\//u, "");
+}
+const NO_PATHS = { oldPath: undefined, newPath: undefined };
+/** Best effort for `diff --git a/x b/x` when no `---`/`+++`/rename lines name the file (binary, mode-only). */
+function pathsFromDiffLine(line) {
+    if (!line.startsWith(GIT_HEADER)) {
+        return NO_PATHS;
+    }
+    const rest = line.slice(GIT_HEADER.length);
+    const quoted = /^("(?:[^"\\]|\\.)*"|\S+) ("(?:[^"\\]|\\.)*"|\S+)$/u.exec(rest);
+    if (quoted?.[1] !== undefined && quoted[2] !== undefined) {
+        return { oldPath: stripSide(quoted[1]), newPath: stripSide(quoted[2]) };
+    }
+    // Unquoted paths with spaces: both sides are equal unless renamed, so split in the middle.
+    const half = /^a\/(.+) b\/(.+)$/u.exec(rest);
+    if (half?.[1] !== undefined && half[2] !== undefined) {
+        return { oldPath: half[1], newPath: half[2] };
+    }
+    return NO_PATHS;
+}
+/* ------------------------------------------------------------------------------------------ */
+/* Files                                                                                      */
+/* ------------------------------------------------------------------------------------------ */
+function withoutTrailingBlanks(lines) {
+    let end = lines.length;
+    while (end > 0 && lines[end - 1] === "")
+        end -= 1;
+    return lines.slice(0, end);
+}
+/** The patch's lines, CRLF read as LF, without the blank lines a patch often ends with. */
+function patchLines(text) {
+    return withoutTrailingBlanks(text.replaceAll("\r\n", "\n").split("\n"));
+}
+/**
+ * Where each file starts: its `diff --git` line; in a patch without them (`diff -u`, hand-written),
+ * a `---` line, then `+++`, then a hunk. A removed `-- x` line before an added `++ y` one looks
+ * the same only at the end of a hunk with no trailing context, so a `---` line alone never splits.
+ * Bare hunks are one file.
+ */
+function sectionStarts(lines) {
+    const git = lines.flatMap((line, index) => (line.startsWith(GIT_HEADER) ? [index] : []));
+    if (git.length > 0)
+        return git;
+    const unified = lines.flatMap((line, index) => line.startsWith("--- ") &&
+        (lines[index + 1] ?? "").startsWith("+++ ") &&
+        HUNK_HEADER.test(lines[index + 2] ?? "")
+        ? [index]
+        : []);
+    if (unified.length > 0)
+        return unified;
+    return lines.some((line) => HUNK_HEADER.test(line)) ? [0] : [];
+}
+/** The patch's files as runs of lines. Text before the first one (a commit message) belongs to none. */
+function fileSections(lines) {
+    const starts = sectionStarts(lines);
+    return starts.map((start, index) => withoutTrailingBlanks(lines.slice(start, starts[index + 1])));
+}
+/** Reads one header line (before the first hunk) into `header`. */
+function readHeaderLine(line, header) {
+    if (line.startsWith("--- ")) {
+        header.oldPath = stripSide(line.slice(4));
+        if (header.oldPath === undefined)
+            header.created = true;
+    }
+    else if (line.startsWith("+++ ")) {
+        header.newPath = stripSide(line.slice(4));
+        if (header.newPath === undefined)
+            header.deleted = true;
+    }
+    else if (line.startsWith("new file mode")) {
+        header.created = true;
+    }
+    else if (line.startsWith("deleted file mode")) {
+        header.deleted = true;
+    }
+    else if (line.startsWith("rename from ") || line.startsWith("copy from ")) {
+        header.renameFrom = unquoteGitPath(line.slice(line.indexOf(" from ") + 6));
+    }
+    else if (line.startsWith("rename to ") || line.startsWith("copy to ")) {
+        header.renameTo = unquoteGitPath(line.slice(line.indexOf(" to ") + 4));
+    }
+    else if (line.startsWith("Binary files ") || line === "GIT binary patch") {
+        header.binary = true;
+    }
+}
+/** Counts `+`/`-` lines after the first `@@`, where they can no longer be headers. */
+function countChanges(lines) {
+    let additions = 0;
+    let deletions = 0;
+    for (const line of lines) {
+        if (line.startsWith("+")) {
+            additions += 1;
+        }
+        else if (line.startsWith("-")) {
+            deletions += 1;
+        }
+    }
+    return { additions, deletions };
+}
+function parseSection(lines) {
+    const firstHunk = lines.findIndex((line) => HUNK_HEADER.test(line));
+    const headerEnd = firstHunk === -1 ? lines.length : firstHunk;
+    const header = {};
+    for (const line of lines.slice(0, headerEnd)) {
+        readHeaderLine(line, header);
+    }
+    const fallback = pathsFromDiffLine(lines[0] ?? "");
+    const path = header.renameTo ?? header.newPath ?? header.oldPath ?? fallback.newPath ?? fallback.oldPath;
+    const previous = header.renameFrom ?? (header.renameTo === undefined ? undefined : fallback.oldPath);
+    return {
+        path,
+        oldPath: previous !== undefined && previous !== path ? previous : undefined,
+        change: header.created === true ? "added" : header.deleted === true ? "deleted" : "modified",
+        patch: lines.join("\n"),
+        ...countChanges(lines.slice(headerEnd)),
+        binary: header.binary === true,
+    };
+}
+/**
+ * Splits a patch (`git diff`, `diff -u`, or bare hunks) into one entry per file, with line counts.
+ * Text before the first file is ignored; text without hunks or file headers has no files.
+ */
+export function splitPatch(patch) {
+    return fileSections(patchLines(patch)).map(parseSection);
+}
+/** `+`/`-` line counts across every file of a patch; file headers never count. */
+export function patchStats(patch) {
+    let additions = 0;
+    let deletions = 0;
+    for (const file of splitPatch(patch)) {
+        additions += file.additions;
+        deletions += file.deletions;
+    }
+    return { additions, deletions };
+}
+/** A file's hunks. A bare empty body line is a context line whose leading space an editor stripped. */
+function hunksOf(lines) {
+    const hunks = [];
+    for (const line of lines) {
+        const header = HUNK_HEADER.exec(line);
+        if (header !== null) {
+            hunks.push({ oldStart: Number(header[1]), newStart: Number(header[2]), header: line, body: [] });
+        }
+        else {
+            hunks.at(-1)?.body.push(line === "" ? " " : line);
+        }
+    }
+    return hunks;
+}
+const rawHunks = (patch) => fileSections(patchLines(patch)).flatMap(hunksOf);
+/** The `@@` hunks of a patch, in order (the order DiffView indexes them). */
+export function parseHunks(patch) {
+    return rawHunks(patch).map((hunk) => ({
+        oldStart: hunk.oldStart,
+        newStart: hunk.newStart,
+        text: [hunk.header, ...hunk.body].join("\n"),
+        key: hunk.body.join("\n"),
+    }));
+}
+/** Which sides a hunk body line occupies (` ` both, `-` old, `+` new). */
+const LINE_SIDES = {
+    " ": { old: true, new: true },
+    "-": { old: true, new: false },
+    "+": { old: false, new: true },
+};
+/** The text of `line` on one side of a patch, when the patch shows it. */
+export function lineText(patch, side, line) {
+    for (const hunk of rawHunks(patch)) {
+        const at = { old: hunk.oldStart, new: hunk.newStart };
+        for (const raw of hunk.body) {
+            const sides = LINE_SIDES[raw.charAt(0)];
+            if (sides === undefined)
+                continue;
+            if (sides[side] && at[side] === line)
+                return raw.slice(1);
+            if (sides.old)
+                at.old += 1;
+            if (sides.new)
+                at.new += 1;
+        }
+    }
+    return undefined;
+}
+/**
+ * Makes hand-written / model-written patches parse cleanly: CRLF → LF, no trailing newline, and
+ * bare empty lines inside hunks become the " " context lines they were meant to be (editors and
+ * LLMs routinely strip that leading space).
+ */
+export function normalizePatch(patch) {
+    let inHunk = false;
+    return patchLines(patch)
+        .map((line) => {
+        if (line.startsWith("@@"))
+            inHunk = true;
+        else if (line.startsWith("diff "))
+            inHunk = false;
+        else if (inHunk && line === "")
+            return " ";
+        return line;
+    })
+        .join("\n");
+}
+/* ------------------------------------------------------------------------------------------ */
+/* Building                                                                                   */
+/* ------------------------------------------------------------------------------------------ */
+/** A git-style patch of one file from its hunks' unified-diff text, so DiffView can render it. */
+export function buildFilePatch(path, change, hunks) {
+    const head = [`diff --git a/${path} b/${path}`];
+    if (change === "added")
+        head.push("new file mode 100644", "--- /dev/null", `+++ b/${path}`);
+    else if (change === "deleted")
+        head.push("deleted file mode 100644", `--- a/${path}`, "+++ /dev/null");
+    else
+        head.push(`--- a/${path}`, `+++ b/${path}`);
+    return [...head, ...hunks].join("\n");
+}
+/** A patch that adds `content` as a new file, so new files render like any other diff. */
+export function newFilePatch(path, content) {
+    const lines = content === "" ? [] : content.replace(/\n$/u, "").split("\n");
+    if (lines.length === 0)
+        return buildFilePatch(path, "added", []);
+    const body = lines.map((line) => `+${line}`);
+    if (!content.endsWith("\n"))
+        body.push(NO_NEWLINE);
+    return buildFilePatch(path, "added", [[`@@ -0,0 +1,${lines.length} @@`, ...body].join("\n")]);
+}
+/* ------------------------------------------------------------------------------------------ */
+/* Parsed diffs (@pierre/diffs)                                                               */
+/* ------------------------------------------------------------------------------------------ */
+/** Counts `+` / `−` lines across all hunks. */
+export function getDiffStats(diff) {
+    let additions = 0;
+    let deletions = 0;
+    for (const hunk of diff.hunks) {
+        additions += hunk.additionLines;
+        deletions += hunk.deletionLines;
+    }
+    return { additions, deletions };
+}
+const stripEol = (line) => (line ?? "").replace(/\r?\n$/u, "");
+/**
+ * One hunk as unified-diff text (`@@ … @@` header plus ` `/`-`/`+` lines and the no-newline
+ * marker), e.g. to quote in a message or to compare with a patch's hunk.
+ */
+export function getHunkExcerpt(diff, hunkIndex) {
+    const hunk = diff.hunks[hunkIndex];
+    if (!hunk)
+        return "";
+    const context = hunk.hunkContext?.trim();
+    const out = [
+        `@@ -${hunk.deletionStart},${hunk.deletionCount} +${hunk.additionStart},${hunk.additionCount} @@${context ? ` ${context}` : ""}`,
+    ];
+    // Where each side's last line ends: git's no-newline marker follows that line.
+    let oldEnd = 0;
+    let newEnd = 0;
+    for (const block of hunk.hunkContent) {
+        if (block.type === "context") {
+            for (let i = 0; i < block.lines; i++)
+                out.push(` ${stripEol(diff.additionLines[block.additionLineIndex + i])}`);
+            if (block.lines > 0) {
+                oldEnd = out.length;
+                newEnd = out.length;
+            }
+            continue;
+        }
+        for (let i = 0; i < block.deletions; i++)
+            out.push(`-${stripEol(diff.deletionLines[block.deletionLineIndex + i])}`);
+        if (block.deletions > 0)
+            oldEnd = out.length;
+        for (let i = 0; i < block.additions; i++)
+            out.push(`+${stripEol(diff.additionLines[block.additionLineIndex + i])}`);
+        if (block.additions > 0)
+            newEnd = out.length;
+    }
+    const markers = new Set([
+        ...(hunk.noEOFCRDeletions && oldEnd > 0 ? [oldEnd] : []),
+        ...(hunk.noEOFCRAdditions && newEnd > 0 ? [newEnd] : []),
+    ]);
+    for (const at of [...markers].toSorted((a, b) => b - a))
+        out.splice(at, 0, NO_NEWLINE);
+    return out.join("\n");
+}

package/dist/lib/path.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Paths as people read them, from any machine: a daemon on Windows writes `\`, so each helper takes
+ * either separator and keeps the one it found. `@nibapp/ui/path`, a preview API: it may change in a
+ * minor version before 1.0.
+ */
+/**
+ * `src/auth/login.ts` → `["src/auth/", "login.ts"]`: the folder with its separator, then the name.
+ * Either separator; a trailing separator doesn't count (a lone root stays the folder).
+ */
+export declare function splitPath(path: string): readonly [dir: string, name: string];
+/** A path's last segment, either separator; a trailing separator doesn't count. */
+export declare function basename(path: string): string;
+/**
+ * Everything before a path's last segment, separators as they were: "" for a bare name, the root
+ * itself for a file at a root (`/a` → `/`, `C:\a` → `C:\`); a trailing separator doesn't count.
+ */
+export declare function dirname(path: string): string;
+/** Whether a path is absolute on any machine: `/…`, `C:\…` or `C:/…`, or a UNC `\\server\share`. */
+export declare function isAbsolutePath(path: string): boolean;
+/**
+ * A relative `path` against `root`, joined with the separator `root` writes and no doubled one
+ * (`C:\proj` + `src/a.ts` → `C:\proj\src\a.ts`); an absolute or `~` path stays as it is.
+ */
+export declare function joinPath(root: string, path: string): string;
+/**
+ * A path with `.` and `..` resolved and `/` between its segments, its drive letter upper-cased, so
+ * two spellings of one path compare equal (`c:\proj\.\src\..\a.ts` → `C:/proj/a.ts`).
+ */
+export declare function normalizePath(path: string): string;
+/**
+ * `path` relative to `root` when it lies under it, either separator and either drive-letter case,
+ * written with the separator `path` uses; undefined outside it, or for `root` itself.
+ */
+export declare function pathUnder(path: string, root: string): string | undefined;

package/dist/lib/path.js

@@ -0,0 +1,85 @@
+/**
+ * Paths as people read them, from any machine: a daemon on Windows writes `\`, so each helper takes
+ * either separator and keeps the one it found. `@nibapp/ui/path`, a preview API: it may change in a
+ * minor version before 1.0.
+ */
+/**
+ * `src/auth/login.ts` → `["src/auth/", "login.ts"]`: the folder with its separator, then the name.
+ * Either separator; a trailing separator doesn't count (a lone root stays the folder).
+ */
+export function splitPath(path) {
+    const trimmed = path.replace(/(.)[/\\]+$/u, "$1");
+    const cut = Math.max(trimmed.lastIndexOf("/"), trimmed.lastIndexOf("\\")) + 1;
+    return [trimmed.slice(0, cut), trimmed.slice(cut)];
+}
+/** A path's last segment, either separator; a trailing separator doesn't count. */
+export function basename(path) {
+    return splitPath(path)[1];
+}
+/** A path's root alone: `/`, `\`, `C:\` or `C:/`. */
+const ROOT = /^(?:[/\\]|[A-Za-z]:[/\\])$/u;
+/**
+ * Everything before a path's last segment, separators as they were: "" for a bare name, the root
+ * itself for a file at a root (`/a` → `/`, `C:\a` → `C:\`); a trailing separator doesn't count.
+ */
+export function dirname(path) {
+    const [dir] = splitPath(path);
+    return ROOT.test(dir) ? dir : dir.replace(/[/\\]+$/u, "");
+}
+/** Whether a path is absolute on any machine: `/…`, `C:\…` or `C:/…`, or a UNC `\\server\share`. */
+export function isAbsolutePath(path) {
+    return path.startsWith("/") || path.startsWith("\\\\") || /^[A-Za-z]:[/\\]/u.test(path);
+}
+/** The separator a path writes: `\` when it has backslashes and no `/`, else `/`. */
+function separatorOf(path) {
+    return path.includes("\\") && !path.includes("/") ? "\\" : "/";
+}
+/**
+ * A relative `path` against `root`, joined with the separator `root` writes and no doubled one
+ * (`C:\proj` + `src/a.ts` → `C:\proj\src\a.ts`); an absolute or `~` path stays as it is.
+ */
+export function joinPath(root, path) {
+    if (isAbsolutePath(path) || path.startsWith("~"))
+        return path;
+    const separator = separatorOf(root);
+    const rest = path.replace(/^\.[/\\]/u, "").replace(/^[/\\]+/u, "");
+    const base = root.replace(/(.)[/\\]+$/u, "$1");
+    if (rest === "")
+        return base;
+    const joined = separator === "\\" ? rest.replaceAll("/", "\\") : rest;
+    return base.endsWith(separator) ? `${base}${joined}` : `${base}${separator}${joined}`;
+}
+/**
+ * A path with `.` and `..` resolved and `/` between its segments, its drive letter upper-cased, so
+ * two spellings of one path compare equal (`c:\proj\.\src\..\a.ts` → `C:/proj/a.ts`).
+ */
+export function normalizePath(path) {
+    const unc = path.startsWith("\\\\") || path.startsWith("//");
+    const drive = /^([A-Za-z]):/u.exec(path)?.[1];
+    const rest = drive === undefined ? path : path.slice(2);
+    const rooted = unc || /^[/\\]/u.test(rest);
+    const segments = [];
+    for (const segment of rest.split(/[/\\]+/u)) {
+        if (segment === "" || segment === ".")
+            continue;
+        if (segment === "..")
+            segments.pop();
+        else
+            segments.push(segment);
+    }
+    const head = unc ? "//" : `${drive === undefined ? "" : `${drive.toUpperCase()}:`}${rooted ? "/" : ""}`;
+    return `${head}${segments.join("/")}`;
+}
+/**
+ * `path` relative to `root` when it lies under it, either separator and either drive-letter case,
+ * written with the separator `path` uses; undefined outside it, or for `root` itself.
+ */
+export function pathUnder(path, root) {
+    const base = normalizePath(root);
+    const prefix = base.endsWith("/") ? base : `${base}/`;
+    const full = normalizePath(path);
+    if (!full.startsWith(prefix) || full.length === prefix.length)
+        return undefined;
+    const relative = full.slice(prefix.length);
+    return separatorOf(path) === "\\" ? relative.replaceAll("/", "\\") : relative;
+}

package/dist/lib/search.d.ts

@@ -0,0 +1,10 @@
+/**
+ * How every search box compares text: one rule, so "é", "ё" and full-width
+ * letters match the same way in the palette, Settings, the provider directory and the model picker.
+ */
+/** Lower-case, compatibility-decomposed, without combining marks ("Émoji" → "emoji", "ёлка" → "елка"), trimmed. */
+export declare function normalizeForSearch(text: string): string;
+/** The query's normalised terms; empty for a blank query. */
+export declare function searchTerms(query: string): string[];
+/** Every term of `query` appears in `haystack`; a blank query matches everything. */
+export declare function matchesTerms(haystack: string, query: string): boolean;

package/dist/lib/search.js

@@ -0,0 +1,20 @@
+/**
+ * How every search box compares text: one rule, so "é", "ё" and full-width
+ * letters match the same way in the palette, Settings, the provider directory and the model picker.
+ */
+/** Lower-case, compatibility-decomposed, without combining marks ("Émoji" → "emoji", "ёлка" → "елка"), trimmed. */
+export function normalizeForSearch(text) {
+    return text.toLowerCase().normalize("NFKD").replace(/\p{M}/gu, "").trim();
+}
+/** The query's normalised terms; empty for a blank query. */
+export function searchTerms(query) {
+    return normalizeForSearch(query).split(/\s+/u).filter(Boolean);
+}
+/** Every term of `query` appears in `haystack`; a blank query matches everything. */
+export function matchesTerms(haystack, query) {
+    const terms = searchTerms(query);
+    if (terms.length === 0)
+        return true;
+    const text = normalizeForSearch(haystack);
+    return terms.every((term) => text.includes(term));
+}

package/dist/lib/shiki-themes.d.ts

@@ -0,0 +1,7 @@
+import type { ThemeRegistration } from "shiki/types";
+export declare const nibLightTheme: ThemeRegistration;
+export declare const nibDarkTheme: ThemeRegistration;
+export declare const NIB_SHIKI_THEMES: {
+    readonly light: "kit-light";
+    readonly dark: "kit-dark";
+};

package/dist/lib/shiki-themes.js

@@ -0,0 +1,115 @@
+/**
+ * The kit's syntax themes for Shiki (`kit-light` / `kit-dark`). Their colours are tokens: each role's
+ * ramp source is the token spec's `SYNTAX`, and the kit's token generator holds every one to 4.5:1 on
+ * each background code sits on (its `syntax`). Both themes share font styles
+ * so a single `--shiki-light-font-style` var is enough for either scheme. They're named for the kit's
+ * themes, Paper and Graphite.
+ */
+import { palette, syntax } from "../_bundled/tokens/index.js";
+const light = { ...syntax.light, bg: palette.light.gray[0] };
+const dark = { ...syntax.dark, bg: palette.dark.gray[0] };
+const rule = (scope, foreground, fontStyle) => ({
+    scope,
+    settings: fontStyle === undefined ? { foreground } : { foreground, fontStyle },
+});
+function buildTheme(name, type, p) {
+    return {
+        name,
+        displayName: type === "light" ? "Paper" : "Graphite",
+        type,
+        fg: p.fg,
+        bg: p.bg,
+        colors: { "editor.foreground": p.fg, "editor.background": p.bg },
+        settings: [
+            { settings: { foreground: p.fg, background: p.bg } },
+            rule(["comment", "punctuation.definition.comment", "string.comment"], p.comment, "italic"),
+            rule([
+                "keyword",
+                "storage",
+                "storage.type",
+                "storage.modifier",
+                "keyword.control",
+                "keyword.operator.new",
+                "keyword.operator.expression",
+                "keyword.operator.logical.python",
+                "variable.language",
+                "support.type.primitive",
+            ], p.keyword),
+            rule([
+                "keyword.operator",
+                "punctuation",
+                "meta.brace",
+                "punctuation.separator",
+                "punctuation.terminator",
+                "punctuation.accessor",
+                "storage.type.function.arrow",
+            ], p.muted),
+            rule([
+                "string",
+                "string.quoted",
+                "string.template",
+                "punctuation.definition.string",
+                "markup.inline.raw",
+                "markup.raw",
+            ], p.string),
+            rule([
+                "constant.numeric",
+                "constant.language",
+                "constant.character",
+                "constant.other",
+                "variable.other.enummember",
+                "support.constant",
+                "constant.character.escape",
+                "keyword.other.unit",
+            ], p.number),
+            rule([
+                "entity.name.function",
+                "support.function",
+                "meta.function-call entity.name.function",
+                "variable.function",
+                "entity.name.command",
+                "support.type.property-name.json",
+                "entity.name.tag.yaml",
+                "markup.heading",
+                "markup.underline.link",
+                "string.other.link",
+            ], p.fn),
+            rule([
+                "entity.name.type",
+                "entity.name.class",
+                "entity.name.namespace",
+                "entity.other.inherited-class",
+                "support.type",
+                "support.class",
+                "storage.type.cs",
+                "storage.type.java",
+                "entity.name.type.parameter",
+            ], p.type),
+            rule(["entity.name.tag", "meta.tag.sgml", "punctuation.definition.tag.begin.html"], p.tag),
+            rule([
+                "entity.other.attribute-name",
+                "entity.other.attribute-name.class.css",
+                "support.type.vendored.property-name",
+                "support.constant.property-value",
+                "meta.decorator",
+                "punctuation.decorator",
+            ], p.attribute),
+            rule(["string.regexp", "constant.other.character-class.regexp"], p.regex),
+            rule(["variable", "variable.other", "variable.parameter", "meta.object-literal.key"], p.fg),
+            rule(["support.type.property-name.css", "support.type.property-name"], p.fg),
+            rule(["markup.bold"], p.fg, "bold"),
+            rule(["markup.italic"], p.fg, "italic"),
+            rule(["markup.strikethrough"], p.muted, "strikethrough"),
+            rule(["markup.quote"], p.muted, "italic"),
+            rule(["markup.list", "punctuation.definition.list"], p.muted),
+            rule(["markup.inserted", "punctuation.definition.inserted"], p.inserted),
+            rule(["markup.deleted", "punctuation.definition.deleted"], p.deleted),
+            rule(["markup.changed", "punctuation.definition.changed"], p.number),
+            rule(["meta.diff.range", "meta.diff.header", "meta.diff.index"], p.keyword),
+            rule(["invalid", "invalid.illegal"], p.deleted),
+        ],
+    };
+}
+export const nibLightTheme = buildTheme("kit-light", "light", light);
+export const nibDarkTheme = buildTheme("kit-dark", "dark", dark);
+export const NIB_SHIKI_THEMES = { light: "kit-light", dark: "kit-dark" };