@blcklab/yuirinx 0.1.1

package/dist/cjs/index.cjs

@@ -0,0 +1,600 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  YuirinxError: () => YuirinxError,
+  createHighlighter: () => createHighlighter,
+  escapeHtml: () => escapeHtml,
+  highlight: () => highlight,
+  registerLanguage: () => registerLanguage,
+  registerTheme: () => registerTheme,
+  render: () => render,
+  themeToCss: () => themeToCss,
+  tokenize: () => tokenize
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/core/errors.ts
+var YuirinxError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = "YuirinxError";
+    this.code = code;
+  }
+};
+
+// src/core/grammar.ts
+function normalizeId(value) {
+  return value.trim().toLowerCase();
+}
+function isIncludeRule(rule) {
+  return "include" in rule;
+}
+function stickyPattern(pattern) {
+  const flags = [...pattern.flags].filter((flag) => flag !== "g" && flag !== "y").join("");
+  return new RegExp(pattern.source, `${flags}y`);
+}
+function canMatchEmpty(pattern) {
+  const candidates = ["", "x", " ", "\n", "0"];
+  for (const candidate of candidates) {
+    const probe = stickyPattern(pattern);
+    probe.lastIndex = 0;
+    const match = probe.exec(candidate);
+    if (match && match[0].length === 0) return true;
+  }
+  return false;
+}
+function compileGrammar(grammar) {
+  const id = normalizeId(grammar.id);
+  if (!id) {
+    throw new YuirinxError(
+      "YUIRINX_INVALID_GRAMMAR",
+      "A grammar must have a non-empty id."
+    );
+  }
+  const stateNames = Object.keys(grammar.states);
+  if (stateNames.length === 0) {
+    throw new YuirinxError(
+      "YUIRINX_INVALID_GRAMMAR",
+      `Grammar "${id}" must define at least one state.`
+    );
+  }
+  const initialState = grammar.initialState ?? "root";
+  if (!grammar.states[initialState]) {
+    throw new YuirinxError(
+      "YUIRINX_UNKNOWN_STATE",
+      `Grammar "${id}" uses missing initial state "${initialState}".`
+    );
+  }
+  const compiledStates = {};
+  const fallbackTypes = {};
+  const resolveRules = (stateName, ancestry) => {
+    const state = grammar.states[stateName];
+    if (!state) {
+      throw new YuirinxError(
+        "YUIRINX_UNKNOWN_STATE",
+        `Grammar "${id}" references missing state "${stateName}".`
+      );
+    }
+    if (ancestry.includes(stateName)) {
+      throw new YuirinxError(
+        "YUIRINX_INCLUDE_CYCLE",
+        `Grammar "${id}" has an include cycle: ${[...ancestry, stateName].join(" -> ")}.`
+      );
+    }
+    const rules = [];
+    for (const [index, rule] of state.rules.entries()) {
+      if (isIncludeRule(rule)) {
+        rules.push(...resolveRules(rule.include, [...ancestry, stateName]));
+        continue;
+      }
+      if (canMatchEmpty(rule.pattern)) {
+        throw new YuirinxError(
+          "YUIRINX_EMPTY_PATTERN",
+          `Grammar "${id}", state "${stateName}", rule ${index} can match an empty string.`
+        );
+      }
+      for (const target of [rule.push, rule.next]) {
+        if (typeof target === "string" && !grammar.states[target]) {
+          throw new YuirinxError(
+            "YUIRINX_UNKNOWN_STATE",
+            `Grammar "${id}", state "${stateName}", rule ${index} references missing state "${target}".`
+          );
+        }
+      }
+      rules.push({
+        ...rule,
+        pattern: stickyPattern(rule.pattern),
+        source: rule.pattern.source
+      });
+    }
+    return rules;
+  };
+  for (const stateName of stateNames) {
+    compiledStates[stateName] = resolveRules(stateName, []);
+    fallbackTypes[stateName] = grammar.states[stateName]?.fallbackType ?? "plain";
+  }
+  return {
+    source: grammar,
+    id,
+    initialState,
+    states: compiledStates,
+    fallbackTypes
+  };
+}
+
+// src/core/escape.ts
+var HTML_ESCAPE_RE = /[&<>"']/g;
+var HTML_ENTITIES = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+function escapeHtml(value) {
+  return value.replace(
+    HTML_ESCAPE_RE,
+    (character) => HTML_ENTITIES[character] ?? character
+  );
+}
+
+// src/core/renderer.ts
+var SAFE_COLOR = /^(?:#[\da-f]{3,8}|(?:rgb|hsl)a?\([\d.%+\-,\s]+\)|[a-z]+)$/i;
+function sanitizeColor(value) {
+  return value && SAFE_COLOR.test(value.trim()) ? value.trim() : void 0;
+}
+function sanitizeClassPart(value) {
+  return value.trim().replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function sanitizeClassList(value) {
+  if (!value) return [];
+  return value.split(/\s+/).map(sanitizeClassPart).filter(Boolean);
+}
+function safeClassPrefix(prefix) {
+  return prefix.replace(/[^a-zA-Z0-9_-]+/g, "") || "tok-";
+}
+function classForToken(type, prefix) {
+  const safeType = sanitizeClassPart(type.replace(/\./g, "-")) || "plain";
+  return `${safeClassPrefix(prefix)}${safeType}`;
+}
+function classForFallbackLine(index, prefix) {
+  return `${safeClassPrefix(prefix)}fallback-line-${index}`;
+}
+function styleToDeclarations(style) {
+  if (!style) return "";
+  const declarations = [];
+  const color = sanitizeColor(style.color);
+  const background = sanitizeColor(style.backgroundColor);
+  if (color) declarations.push(`color:${color}`);
+  if (background) declarations.push(`background-color:${background}`);
+  if (style.fontStyle) declarations.push(`font-style:${style.fontStyle}`);
+  if (style.fontWeight) {
+    const weight = {
+      normal: "400",
+      medium: "500",
+      semibold: "600",
+      bold: "700"
+    }[style.fontWeight];
+    declarations.push(`font-weight:${weight}`);
+  }
+  if (style.textDecoration)
+    declarations.push(`text-decoration:${style.textDecoration}`);
+  return declarations.join(";");
+}
+function resolveFallbackPalette(theme) {
+  if (!theme) return [];
+  const explicit = (theme.fallbackPalette ?? []).map((color) => sanitizeColor(color)).filter((color) => Boolean(color));
+  if (explicit.length > 0) return [...new Set(explicit)];
+  const inferred = Object.values(theme.tokens).map((style) => sanitizeColor(style.color)).filter((color) => Boolean(color));
+  const colors = [...new Set(inferred)].slice(0, 8);
+  if (colors.length > 0) return colors;
+  const foreground = sanitizeColor(theme.foreground);
+  return foreground ? [foreground] : [];
+}
+function hashSource(value) {
+  let hash = 2166136261;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function renderFallbackLine(value, lineIndex, seed, palette, mode, prefix) {
+  const paletteIndex = (seed + lineIndex) % palette.length;
+  const escaped = escapeHtml(value);
+  if (mode === "classes") {
+    const classes = [
+      "yuirinx-line",
+      classForFallbackLine(paletteIndex, prefix)
+    ];
+    return `<span class="${escapeHtml(classes.join(" "))}">${escaped}</span>`;
+  }
+  const color = palette[paletteIndex] ?? "";
+  const declarations = styleToDeclarations({ color });
+  return `<span class="yuirinx-line" style="${escapeHtml(declarations)}">${escaped}</span>`;
+}
+function renderFallbackBody(code, options, theme) {
+  if (!code) return "";
+  const palette = resolveFallbackPalette(theme);
+  if (palette.length === 0) return escapeHtml(code);
+  const mode = options.mode ?? "inline";
+  const prefix = options.classPrefix ?? "tok-";
+  const seed = hashSource(code) % palette.length;
+  const newline = /\r\n|\r|\n/g;
+  let lineStart = 0;
+  let lineIndex = 0;
+  let body = "";
+  let match;
+  while ((match = newline.exec(code)) !== null) {
+    body += renderFallbackLine(
+      code.slice(lineStart, match.index),
+      lineIndex,
+      seed,
+      palette,
+      mode,
+      prefix
+    );
+    body += escapeHtml(match[0]);
+    lineStart = newline.lastIndex;
+    lineIndex += 1;
+  }
+  if (lineStart < code.length) {
+    body += renderFallbackLine(
+      code.slice(lineStart),
+      lineIndex,
+      seed,
+      palette,
+      mode,
+      prefix
+    );
+  }
+  return body;
+}
+function wrapBody(body, options, theme, fallbackLines) {
+  if (options.wrap === false) return body;
+  const mode = options.mode ?? "inline";
+  const normalizedThemeId = theme ? sanitizeClassPart(normalizeId(theme.id)) : "";
+  const themeId2 = normalizedThemeId.startsWith("yuirinx-") ? normalizedThemeId.slice("yuirinx-".length) : normalizedThemeId;
+  const preClasses = [
+    "yuirinx",
+    themeId2 ? `yuirinx-theme-${themeId2}` : "",
+    fallbackLines ? "yuirinx-fallback-lines" : "",
+    ...sanitizeClassList(options.preClass)
+  ].filter(Boolean);
+  const language = sanitizeClassPart(normalizeId(options.language ?? "plaintext")) || "plaintext";
+  const codeClasses = [
+    `language-${language}`,
+    ...sanitizeClassList(options.codeClass)
+  ];
+  const containerStyle = mode === "inline" && theme ? styleToDeclarations({
+    color: theme.foreground,
+    backgroundColor: theme.background
+  }) : "";
+  return `<pre class="${escapeHtml(preClasses.join(" "))}"${containerStyle ? ` style="${escapeHtml(containerStyle)}"` : ""}><code class="${escapeHtml(codeClasses.join(" "))}">${body}</code></pre>`;
+}
+function resolveTokenStyle(theme, type) {
+  if (!theme) return void 0;
+  let current = type;
+  while (current) {
+    const style = theme.tokens[current];
+    if (style) return style;
+    const separator = current.lastIndexOf(".");
+    if (separator < 0) break;
+    current = current.slice(0, separator);
+  }
+  return void 0;
+}
+function renderTokens(tokens, options, theme) {
+  const mode = options.mode ?? "inline";
+  const prefix = options.classPrefix ?? "tok-";
+  const body = tokens.map((token) => {
+    const escaped = escapeHtml(token.value);
+    if (token.type === "plain") return escaped;
+    if (mode === "classes") {
+      return `<span class="${escapeHtml(classForToken(token.type, prefix))}">${escaped}</span>`;
+    }
+    const declarations = styleToDeclarations(
+      resolveTokenStyle(theme, token.type)
+    );
+    return declarations ? `<span style="${escapeHtml(declarations)}">${escaped}</span>` : escaped;
+  }).join("");
+  return wrapBody(body, options, theme, false);
+}
+function renderColorLines(code, options, theme) {
+  const colored = code.length > 0 && resolveFallbackPalette(theme).length > 0;
+  const body = renderFallbackBody(code, options, theme);
+  return wrapBody(body, options, theme, colored);
+}
+function themeToCss(theme, options = {}) {
+  const prefix = options.classPrefix ?? "tok-";
+  const normalizedThemeId = sanitizeClassPart(normalizeId(theme.id));
+  const themeId2 = normalizedThemeId.startsWith("yuirinx-") ? normalizedThemeId.slice("yuirinx-".length) : normalizedThemeId;
+  const rawSelector = options.selector ?? `.yuirinx-theme-${themeId2 || "default"}`;
+  const selector = rawSelector.replace(/[{}<>]/g, "").trim() || ".yuirinx";
+  const lines = [];
+  if (options.includeContainer !== false) {
+    const foreground = sanitizeColor(theme.foreground);
+    const background = sanitizeColor(theme.background);
+    const declarations = [
+      foreground ? `color:${foreground}` : "",
+      background ? `background-color:${background}` : ""
+    ].filter(Boolean);
+    lines.push(`${selector}{${declarations.join(";")}}`);
+  }
+  for (const [type, style] of Object.entries(theme.tokens)) {
+    const declarations = styleToDeclarations(style);
+    if (declarations)
+      lines.push(
+        `${selector} .${classForToken(type, prefix)}{${declarations}}`
+      );
+  }
+  for (const [index, color] of resolveFallbackPalette(theme).entries()) {
+    lines.push(
+      `${selector} .${classForFallbackLine(index, prefix)}{color:${color}}`
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/core/tokenizer.ts
+function resolveValue(resolver, match, context) {
+  return typeof resolver === "function" ? resolver(match, context) : resolver;
+}
+function appendToken(tokens, type, value, start) {
+  if (!value) return;
+  const previous = tokens[tokens.length - 1];
+  if (previous && previous.type === type && previous.end === start) {
+    tokens[tokens.length - 1] = {
+      type,
+      value: previous.value + value,
+      start: previous.start,
+      end: start + value.length
+    };
+    return;
+  }
+  tokens.push({ type, value, start, end: start + value.length });
+}
+function publicStack(grammarId, stack) {
+  return stack.map((name) => ({ name, language: grammarId }));
+}
+function applyTransition(rule, match, context, stack, maxStateDepth) {
+  const popCount = rule.pop === true ? 1 : typeof rule.pop === "number" ? rule.pop : 0;
+  if (popCount > 0) {
+    const removable = Math.min(popCount, Math.max(0, stack.length - 1));
+    stack.splice(stack.length - removable, removable);
+  }
+  const next = resolveValue(
+    rule.next,
+    match,
+    context
+  );
+  if (next) stack[stack.length - 1] = next;
+  const push = resolveValue(
+    rule.push,
+    match,
+    context
+  );
+  if (push) {
+    if (stack.length >= maxStateDepth) {
+      throw new YuirinxError(
+        "YUIRINX_STATE_DEPTH_EXCEEDED",
+        `Tokenizer state depth exceeded the configured limit of ${maxStateDepth}.`
+      );
+    }
+    stack.push(push);
+  }
+}
+function tokenizeCompiled(code, grammar, maxStateDepth) {
+  if (!code) return [];
+  const tokens = [];
+  const stack = [grammar.initialState];
+  let offset = 0;
+  while (offset < code.length) {
+    const stateName = stack[stack.length - 1] ?? grammar.initialState;
+    const rules = grammar.states[stateName];
+    if (!rules) {
+      throw new YuirinxError(
+        "YUIRINX_UNKNOWN_STATE",
+        `Grammar "${grammar.id}" entered missing state "${stateName}".`
+      );
+    }
+    let matched = false;
+    for (const rule of rules) {
+      rule.pattern.lastIndex = offset;
+      const match = rule.pattern.exec(code);
+      if (!match) continue;
+      if (match[0].length === 0) {
+        throw new YuirinxError(
+          "YUIRINX_EMPTY_PATTERN",
+          `Grammar "${grammar.id}" produced an empty match in state "${stateName}" from /${rule.source}/.`
+        );
+      }
+      const context = {
+        language: grammar.id,
+        state: stateName,
+        stack: publicStack(grammar.id, stack),
+        offset
+      };
+      const tokenType = resolveValue(
+        rule.type,
+        match,
+        context
+      ) ?? grammar.fallbackTypes[stateName] ?? "plain";
+      appendToken(tokens, tokenType, match[0], offset);
+      applyTransition(rule, match, context, stack, maxStateDepth);
+      offset += match[0].length;
+      matched = true;
+      break;
+    }
+    if (!matched) {
+      appendToken(
+        tokens,
+        grammar.fallbackTypes[stateName] ?? "plain",
+        code[offset] ?? "",
+        offset
+      );
+      offset += 1;
+    }
+  }
+  return tokens;
+}
+
+// src/core/create-highlighter.ts
+var plaintextGrammar = {
+  id: "plaintext",
+  aliases: ["text", "txt", "plain"],
+  states: {
+    root: {
+      rules: [{ type: "plain", pattern: /[\s\S]+/ }]
+    }
+  }
+};
+function themeId(theme) {
+  return normalizeId(theme.id);
+}
+function createHighlighter(options = {}) {
+  const grammars = /* @__PURE__ */ new Map();
+  const canonicalIds = /* @__PURE__ */ new Set();
+  const themes = /* @__PURE__ */ new Map();
+  const maxStateDepth = Math.max(2, options.maxStateDepth ?? 64);
+  const compiledPlaintext = compileGrammar(plaintextGrammar);
+  const plaintextIds = /* @__PURE__ */ new Set([
+    normalizeId(plaintextGrammar.id),
+    ...(plaintextGrammar.aliases ?? []).map(normalizeId)
+  ]);
+  const registerLanguage2 = (grammar) => {
+    const compiled = compileGrammar(grammar);
+    const id = compiled.id;
+    if (grammars.has(id)) {
+      throw new YuirinxError(
+        "YUIRINX_DUPLICATE_LANGUAGE",
+        `Language "${id}" is already registered.`
+      );
+    }
+    const aliases = (grammar.aliases ?? []).map(normalizeId).filter(Boolean);
+    for (const alias of aliases) {
+      if (alias === id || grammars.has(alias)) {
+        throw new YuirinxError(
+          "YUIRINX_DUPLICATE_ALIAS",
+          `Alias "${alias}" for language "${id}" is already registered.`
+        );
+      }
+    }
+    grammars.set(id, compiled);
+    canonicalIds.add(id);
+    for (const alias of aliases) grammars.set(alias, compiled);
+  };
+  const registerTheme2 = (theme) => {
+    const id = themeId(theme);
+    if (!id)
+      throw new YuirinxError(
+        "YUIRINX_DUPLICATE_THEME",
+        "A theme must have a non-empty id."
+      );
+    if (themes.has(id)) {
+      throw new YuirinxError(
+        "YUIRINX_DUPLICATE_THEME",
+        `Theme "${id}" is already registered.`
+      );
+    }
+    themes.set(id, theme);
+  };
+  for (const grammar of options.languages ?? []) registerLanguage2(grammar);
+  for (const theme of options.themes ?? []) registerTheme2(theme);
+  const resolveGrammar = (language) => {
+    if (typeof language !== "string") {
+      return { grammar: compileGrammar(language), unavailable: false };
+    }
+    const id = normalizeId(language);
+    const registered = grammars.get(id);
+    if (registered) return { grammar: registered, unavailable: false };
+    return {
+      grammar: compiledPlaintext,
+      unavailable: !plaintextIds.has(id)
+    };
+  };
+  const resolveTheme = (theme) => {
+    if (!theme)
+      return options.defaultTheme ? themes.get(normalizeId(options.defaultTheme)) : void 0;
+    return typeof theme === "string" ? themes.get(normalizeId(theme)) : theme;
+  };
+  const tokenize2 = (code, language) => tokenizeCompiled(code, resolveGrammar(language).grammar, maxStateDepth);
+  const render2 = (tokens, renderOptions = {}) => renderTokens(tokens, renderOptions, resolveTheme(renderOptions.theme));
+  const highlight2 = (code, highlightOptions) => {
+    const language = highlightOptions.lang ?? options.defaultLanguage ?? "plaintext";
+    const resolved = resolveGrammar(language);
+    const theme = resolveTheme(highlightOptions.theme);
+    const renderOptions = {
+      ...highlightOptions,
+      language: typeof language === "string" ? language : language.id
+    };
+    const fallback = highlightOptions.fallback ?? options.defaultFallback ?? "plaintext";
+    if (resolved.unavailable && fallback === "color-lines") {
+      return renderColorLines(code, renderOptions, theme);
+    }
+    const tokens = tokenizeCompiled(code, resolved.grammar, maxStateDepth);
+    return renderTokens(tokens, renderOptions, theme);
+  };
+  return {
+    highlight: highlight2,
+    tokenize: tokenize2,
+    render: render2,
+    registerLanguage: registerLanguage2,
+    registerTheme: registerTheme2,
+    hasLanguage: (language) => grammars.has(normalizeId(language)),
+    hasTheme: (theme) => themes.has(normalizeId(theme)),
+    getLanguage: (language) => grammars.get(normalizeId(language))?.source,
+    getTheme: (theme) => themes.get(normalizeId(theme)),
+    listLanguages: () => Object.freeze([...canonicalIds]),
+    listThemes: () => Object.freeze([...themes.keys()])
+  };
+}
+
+// src/singleton.ts
+var defaultHighlighter = createHighlighter();
+function highlight(code, options) {
+  return defaultHighlighter.highlight(code, options);
+}
+function tokenize(code, language) {
+  return defaultHighlighter.tokenize(code, language);
+}
+function render(tokens, options) {
+  return defaultHighlighter.render(tokens, options);
+}
+function registerLanguage(grammar) {
+  defaultHighlighter.registerLanguage(grammar);
+}
+function registerTheme(theme) {
+  defaultHighlighter.registerTheme(theme);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  YuirinxError,
+  createHighlighter,
+  escapeHtml,
+  highlight,
+  registerLanguage,
+  registerTheme,
+  render,
+  themeToCss,
+  tokenize
+});