jsmdcui 0.3.0

package/src/display/ansi-style.js

@@ -0,0 +1,60 @@
+const BASIC = {
+  black: 0,
+  red: 1,
+  green: 2,
+  yellow: 3,
+  blue: 4,
+  magenta: 5,
+  cyan: 6,
+  white: 7,
+  brightblack: 8,
+  lightblack: 8,
+  brightred: 9,
+  lightred: 9,
+  brightgreen: 10,
+  lightgreen: 10,
+  brightyellow: 11,
+  lightyellow: 11,
+  brightblue: 12,
+  lightblue: 12,
+  brightmagenta: 13,
+  lightmagenta: 13,
+  brightcyan: 14,
+  lightcyan: 14,
+  brightwhite: 15,
+  lightwhite: 15,
+};
+
+export function styleToAnsi(style = {}) {
+  const codes = [0];
+  if (style.bold) codes.push(1);
+  if (style.italic) codes.push(3);
+  if (style.underline) codes.push(4);
+  if (style.reverse) codes.push(7);
+  codes.push(...colorCodes(style.fg, false));
+  codes.push(...colorCodes(style.bg, true));
+  return `\x1b[${codes.join(";")}m`;
+}
+
+export function resetStyle() {
+  return "\x1b[0m";
+}
+
+export function styleResetTo(style = {}) {
+  return resetStyle() + styleToAnsi(style);
+}
+
+function colorCodes(color, background) {
+  if (color == null || color === "default") return [];
+  const base = background ? 48 : 38;
+  if (typeof color === "number") return [base, 5, color];
+  const value = String(color).toLowerCase();
+  if (/^#[0-9a-f]{6}$/.test(value)) {
+    const r = Number.parseInt(value.slice(1, 3), 16);
+    const g = Number.parseInt(value.slice(3, 5), 16);
+    const b = Number.parseInt(value.slice(5, 7), 16);
+    return [base, 2, r, g, b];
+  }
+  if (value in BASIC) return [base, 5, BASIC[value]];
+  return [];
+}

package/src/highlight/highlighter.js

@@ -0,0 +1,243 @@
+export class Highlighter {
+  constructor(definition, definitions = []) {
+    this.definition = definition;
+    this.definitions = definitions;
+    this.rules = resolveRules(definition?.rules ?? [], definitions, new Set());
+  }
+
+  highlightLine(line, state = null, progress = null) {
+    const text = String(line);
+    const changes = new Map([[0, state?.group ?? "default"]]);
+    const nextState = state
+      ? scanRegion(changes, text, 0, state, this.rules, progress)
+      : scanTop(changes, text, 0, this.rules, progress);
+    return {
+      changes: normalizeChanges(changes, text.length),
+      state: nextState,
+    };
+  }
+
+  highlightString(input) {
+    const matches = [];
+    let state = null;
+    for (const line of String(input).split("\n")) {
+      const result = this.highlightLine(line, state);
+      matches.push(result.changes);
+      state = result.state;
+    }
+    return matches;
+  }
+}
+
+export function resolveRules(rules, definitions, seen) {
+  const out = [];
+  for (const rule of rules) {
+    if (rule.type === "include") {
+      if (seen.has(rule.include)) continue;
+      seen.add(rule.include);
+      const def = definitions.find((candidate) => candidate.filetype === rule.include);
+      if (def) out.push(...resolveRules(def.rules, definitions, seen));
+    } else if (rule.type === "region") {
+      out.push({ ...rule, rules: resolveRules(rule.rules ?? [], definitions, new Set(seen)) });
+    } else {
+      out.push(rule);
+    }
+  }
+  return out;
+}
+
+export function flattenRules(rules, definitions, seen) {
+  return resolveRules(rules, definitions, seen).flatMap((rule) => {
+    if (rule.type === "region") return flattenRules(rule.rules ?? [], definitions, new Set(seen));
+    return rule.type === "pattern" ? [rule] : [];
+  });
+}
+
+function scanTop(changes, line, pos, rules, progress = null) {
+  let cursor = pos;
+  while (cursor <= line.length) {
+    progress?.(cursor);
+    const regionStart = findFirstRegion(rules, line, cursor, progress);
+    if (!regionStart) {
+      applyPatterns(changes, line, cursor, line.length, rules, "default", progress);
+      changes.set(line.length, "default");
+      progress?.(line.length);
+      return null;
+    }
+
+    applyPatterns(changes, line, cursor, regionStart.start, rules, "default", progress);
+    changes.set(regionStart.start, regionStart.region.limitGroup ?? "default");
+    changes.set(regionStart.end, regionStart.region.group);
+    progress?.(regionStart.end);
+
+    const state = scanRegion(changes, line, regionStart.end, regionStart.region, rules, progress);
+    if (state) return state;
+    return null;
+  }
+  return null;
+}
+
+function scanRegion(changes, line, pos, region, rootRules, progress = null) {
+  let cursor = pos;
+  const rules = region.rules ?? [];
+  while (cursor <= line.length) {
+    progress?.(cursor);
+    const end = findMatch(region.end, line, cursor, region.skip, progress);
+    const nested = findFirstRegion(rules, line, cursor, progress);
+
+    if (end && (!nested || end.start <= nested.start)) {
+      applyPatterns(changes, line, cursor, end.start, rules, region.group, progress);
+      changes.set(end.start, region.limitGroup ?? region.group);
+      changes.set(end.end, parentGroup(region));
+      progress?.(end.end);
+      if (region.parent) return scanRegion(changes, line, end.end, region.parent, rootRules, progress);
+      return scanTop(changes, line, Math.max(end.end, end.start + 1), rootRules, progress);
+    }
+
+    if (nested) {
+      applyPatterns(changes, line, cursor, nested.start, rules, region.group, progress);
+      changes.set(nested.start, nested.region.limitGroup ?? region.group);
+      const child = { ...nested.region, parent: region };
+      changes.set(nested.end, child.group);
+      progress?.(nested.end);
+      const state = scanRegion(changes, line, nested.end, child, rootRules, progress);
+      if (state) return state;
+      cursor = Math.max(nested.end + 1, nextChangeAfter(changes, nested.end));
+      continue;
+    }
+
+    applyPatterns(changes, line, cursor, line.length, rules, region.group, progress);
+    changes.set(line.length, region.group);
+    progress?.(line.length);
+    return region;
+  }
+  return region;
+}
+
+function applyPatterns(changes, line, start, end, rules, fallbackGroup, progress = null) {
+  if (end < start) return;
+  const length = end - start;
+  if (length === 0) {
+    if (!changes.has(start)) changes.set(start, fallbackGroup);
+    return;
+  }
+  // Mirror Go's fullHighlights approach: later rules overwrite all positions in their match range,
+  // preventing earlier rules (e.g. symbol.operator matching "!") from leaking into spans that a
+  // later rule (e.g. the shebang comment pattern) should own entirely.
+  const fullHighlights = new Array(length).fill(null);
+  for (const rule of rules) {
+    if (rule.type !== "pattern" || !rule.regex) continue;
+    for (const match of findAllMatches(rule.regex, line, start, end, progress)) {
+      if (match.start === match.end) continue;
+      const lo = Math.max(match.start, start) - start;
+      const hi = Math.min(match.end, end) - start;
+      for (let i = lo; i < hi; i++) fullHighlights[i] = rule.group;
+    }
+    progress?.(end);
+  }
+  // Emit only color-change boundaries into the changes map (same as Go's transition loop).
+  let prev = changes.get(start) ?? fallbackGroup;
+  for (let i = 0; i < length; i++) {
+    const g = fullHighlights[i] ?? fallbackGroup;
+    if (g !== prev) { changes.set(start + i, g); prev = g; }
+  }
+  if (!changes.has(start)) changes.set(start, fullHighlights[0] ?? fallbackGroup);
+  if (!changes.has(end)) changes.set(end, fallbackGroup);
+}
+
+function findFirstRegion(rules, line, pos, progress = null) {
+  let best = null;
+  for (const region of rules.filter((rule) => rule.type === "region" && rule.start)) {
+    const match = findMatch(region.start, line, pos, region.skip, progress);
+    if (!match) continue;
+    if (!best || match.start < best.start) best = { ...match, region };
+  }
+  return best;
+}
+
+function findMatch(regex, line, pos, skip, progress = null) {
+  if (!regex) return null;
+  const masked = skip ? maskSkipped(line, skip) : line;
+  const global = globalize(regex);
+  global.lastIndex = pos;
+  let match;
+  if (!progress) {
+    match = global.exec(masked);
+    if (!match) return null;
+    const start = match.index ?? 0;
+    return { start, end: start + match[0].length };
+  }
+  while ((match = global.exec(masked)) !== null) {
+    const start = match.index ?? 0;
+    const end = start + match[0].length;
+    progress?.(start);
+    if (start >= pos) return { start, end };
+    if (match[0].length === 0) global.lastIndex++;
+  }
+  progress?.(line.length);
+  return null;
+}
+
+function findAllMatches(regex, line, start, end, progress = null) {
+  const out = [];
+  const global = globalize(regex);
+  global.lastIndex = start;
+  let match;
+  if (!progress) {
+    while ((match = global.exec(line)) !== null) {
+      const matchStart = match.index ?? 0;
+      if (matchStart >= end) break;
+      const matchEnd = matchStart + match[0].length;
+      if (match[0].length === 0) {
+        global.lastIndex++;
+        continue;
+      }
+      if (matchEnd > start) out.push({ start: Math.max(matchStart, start), end: Math.min(matchEnd, end) });
+    }
+    return out;
+  }
+  while ((match = global.exec(line)) !== null) {
+    const matchStart = match.index ?? 0;
+    const matchEnd = matchStart + match[0].length;
+    if (matchStart >= end) break;
+    progress?.(matchStart);
+    if (match[0].length === 0) {
+      global.lastIndex++;
+      continue;
+    }
+    if (matchEnd <= start || matchStart >= end) continue;
+    out.push({ start: Math.max(matchStart, start), end: Math.min(matchEnd, end) });
+  }
+  progress?.(end);
+  return out;
+}
+
+function maskSkipped(line, skip) {
+  return line.replace(globalize(skip), (value) => "\0".repeat(value.length));
+}
+
+function normalizeChanges(changes, lineLength) {
+  const normalized = new Map([...changes.entries()]
+    .filter(([index]) => index >= 0 && index <= lineLength)
+    .sort(([a], [b]) => a - b));
+  if (!normalized.has(0)) normalized.set(0, "default");
+  if (!normalized.has(lineLength)) normalized.set(lineLength, normalized.get([...normalized.keys()].at(-1)) ?? "default");
+  return new Map([...normalized.entries()].sort(([a], [b]) => a - b));
+}
+
+function parentGroup(region) {
+  return region.parent?.group ?? "default";
+}
+
+function nextChangeAfter(changes, index) {
+  for (const key of [...changes.keys()].sort((a, b) => a - b)) {
+    if (key > index) return key;
+  }
+  return index + 1;
+}
+
+function globalize(regex) {
+  const flags = new Set(regex.flags.split(""));
+  flags.add("g");
+  return new RegExp(regex.source, [...flags].join(""));
+}

package/src/highlight/parser.js

@@ -0,0 +1,225 @@
+import { basename } from "node:path";
+
+export class SyntaxHeader {
+  constructor({ filetype = "", filename = "", header = "", signature = "" } = {}) {
+    this.filetype = filetype;
+    this.filename = filename;
+    this.header = header;
+    this.signature = signature;
+    this.fileNameRegex = compileRegex(filename);
+    this.headerRegex = compileRegex(header);
+    this.signatureRegex = compileRegex(signature);
+  }
+
+  matchFileName(path) {
+    return !!this.fileNameRegex?.test(basename(path));
+  }
+
+  matchHeader(firstLine) {
+    return !!this.headerRegex?.test(firstLine);
+  }
+
+  hasSignature() {
+    return !!this.signatureRegex;
+  }
+
+  matchSignature(line) {
+    return !!this.signatureRegex?.test(line);
+  }
+}
+
+export class SyntaxDefinition {
+  constructor(header, source, text = "") {
+    this.header = header;
+    this.filetype = header.filetype;
+    this.source = source;
+    this.rules = parseRules(source.rules ?? []);
+    this.autocompleteWords = scanAutocompleteWordsFromText(text);
+  }
+}
+
+export async function loadSyntaxDefinitions(runtime) {
+  const headers = new Map();
+  const headerPromises = runtime.list(4).map(async (file) => {
+    try {
+      const text = await file.text();
+      headers.set(file.name, parseHeaderFile(text));
+    } catch {}
+  });
+  await Promise.allSettled(headerPromises);
+
+  const defPromises = runtime.list(1).map(async (file) => {
+    let text = "";
+    let activeFile = file;
+    let source = null;
+    let usedFallback = false;
+    try {
+      text = await file.text();
+      source = Bun.YAML.parse(text);
+    } catch (e) {
+      const fallback = file.real ? runtime.fallback?.(1, file.name) : null;
+      if (fallback) {
+        try {
+          text = await fallback.text();
+          source = Bun.YAML.parse(text);
+          activeFile = fallback;
+          usedFallback = true;
+          console.error("Failed to load user syntax yaml, using built-in fallback:", file.name);
+        } catch {}
+      }
+    }
+    const header = headers.get(activeFile.name) ?? (source ? parseHeaderYaml(source) : parseHeaderTextFallback(text, activeFile.name));
+    if (!source) {
+      console.error("Failed to load syntax yaml:", file.name);
+      console.error("  Will not highlight this kind of file");
+      console.error("  @ loadSyntaxDefinitions ");
+    } else if (usedFallback) {
+      // keep the fallback path visible in logs, but do not fail the load
+    }
+    return new SyntaxDefinition(header, source ?? { rules: [] }, text);
+  });
+  
+  const definitions = await Promise.allSettled(defPromises);
+  return definitions
+    .filter((result) => result.status === "fulfilled")
+    .map((result) => result.value);
+}
+
+export function detectSyntax(definitions, { path = "", firstLine = "", lines = [] } = {}) {
+  for (const def of definitions) {
+    if (path && def.header.matchFileName(path)) return def;
+  }
+  for (const def of definitions) {
+    if (firstLine && def.header.matchHeader(firstLine)) return def;
+  }
+  for (const def of definitions) {
+    if (!def.header.hasSignature()) continue;
+    if (lines.some((line) => def.header.matchSignature(line))) return def;
+  }
+  return null;
+}
+
+export function parseHeaderFile(text) {
+  const [filetype = "", filename = "", header = "", signature = ""] = String(text).split(/\r?\n/);
+  return new SyntaxHeader({ filetype, filename, header, signature });
+}
+
+export function parseHeaderYaml(source) {
+  return new SyntaxHeader({
+    filetype: source?.filetype ?? "",
+    filename: source?.detect?.filename ?? "",
+    header: source?.detect?.header ?? "",
+    signature: source?.detect?.signature ?? "",
+  });
+}
+
+function parseHeaderTextFallback(text, fileName = "") {
+  const source = String(text ?? "");
+  const fallbackType = String(fileName).replace(/\.ya?ml$/i, "");
+  const filetype = rawYamlScalar(source.match(/^filetype:[ \t]*(.*)$/m)?.[1]) || fallbackType;
+  return new SyntaxHeader({
+    filetype,
+    filename: rawYamlDetectScalar(source, "filename"),
+    header: rawYamlDetectScalar(source, "header"),
+    signature: rawYamlDetectScalar(source, "signature"),
+  });
+}
+
+function rawYamlDetectScalar(text, key) {
+  const detect = text.match(/^detect:[ \t]*(?:#.*)?(?:\r?\n)((?:[ \t]+[^\n]*\r?\n?)*)/m)?.[1] ?? "";
+  return rawYamlScalar(detect.match(new RegExp(`^[ \t]+${key}:[ \t]*(.*)$`, "m"))?.[1]);
+}
+
+function rawYamlScalar(value) {
+  if (value == null) return "";
+  let out = String(value).trim();
+  if (!out) return "";
+  if (out.startsWith("\"") && out.endsWith("\"")) {
+    try { return JSON.parse(out); } catch { return out.slice(1, -1); }
+  }
+  if (out.startsWith("'") && out.endsWith("'")) return out.slice(1, -1).replaceAll("''", "'");
+  return out;
+}
+
+function scanAutocompleteWordsFromText(text) {
+  const source = String(text ?? "");
+  const words = [];
+  const seen = new Set();
+  let i = 0;
+  while (i < source.length) {
+    if (!isSyntaxWordChar(source[i])) { i++; continue; }
+    let j = i;
+    while (j < source.length && isSyntaxWordChar(source[j])) j++;
+    const word = source.slice(i, j);
+    if (!seen.has(word)) {
+      seen.add(word);
+      words.push(word);
+    }
+    i = j;
+  }
+  return words;
+}
+
+function isSyntaxWordChar(ch) {
+  if (!ch) return false;
+  const cp = ch.codePointAt(0);
+  if ((cp >= 65 && cp <= 90) || (cp >= 97 && cp <= 122) || (cp >= 48 && cp <= 57) || cp === 95) return true;
+  if (cp <= 127) return false;
+  return /\p{L}|\p{N}/u.test(ch);
+}
+
+function parseRules(rules) {
+  return rules.map((rule) => parseRule(rule)).filter(Boolean);
+}
+
+function parseRule(rule) {
+  if (typeof rule === "string") return { type: "include", include: rule };
+  if (!rule || typeof rule !== "object") return null;
+  const [[group, value]] = Object.entries(rule);
+  if (group === "include") return { type: "include", include: value };
+  if (typeof value === "string") return { type: "pattern", group, regex: compileRegex(value), source: value };
+  if (value && typeof value === "object") {
+    return {
+      type: "region",
+      group,
+      start: compileRegex(value.start),
+      end: compileRegex(value.end),
+      skip: compileRegex(value.skip),
+      limitGroup: value["limit-group"] ?? group,
+      rules: parseRules(value.rules ?? []),
+      source: value,
+    };
+  }
+  return null;
+}
+
+function compileRegex(pattern) {
+  if (!pattern) return null;
+  const translated = translateGoRegexp(pattern);
+  try {
+    return new RegExp(translated, "u");
+  } catch {
+    try {
+      return new RegExp(translated);
+    } catch {
+      return null;
+    }
+  }
+}
+
+function translateGoRegexp(pattern) {
+  return String(pattern)
+    .replaceAll("[[:alnum:]]", "[A-Za-z0-9]")
+    .replaceAll("[[:alpha:]]", "[A-Za-z]")
+    .replaceAll("[[:ascii:]]", "[\\x00-\\x7F]")
+    .replaceAll("[[:blank:]]", "[ \\t]")
+    .replaceAll("[[:cntrl:]]", "[\\x00-\\x1F\\x7F]")
+    .replaceAll("[[:digit:]]", "[0-9]")
+    .replaceAll("[[:graph:]]", "[!-~]")
+    .replaceAll("[[:lower:]]", "[a-z]")
+    .replaceAll("[[:print:]]", "[ -~]")
+    .replaceAll("[[:space:]]", "\\s")
+    .replaceAll("[[:upper:]]", "[A-Z]")
+    .replaceAll("[[:word:]]", "[A-Za-z0-9_]")
+    .replaceAll("[[:xdigit:]]", "[A-Fa-f0-9]");
+}