@blcklab/yuirinx 0.1.1 → 0.1.2

package/dist/esm/core/renderer.js

@@ -0,0 +1,215 @@
+import { escapeHtml } from "./escape.js";
+import { normalizeId } from "./grammar.js";
+const 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 classesForToken(type, prefix) {
+  const parts = type.split(".").filter(Boolean);
+  if (parts.length === 0) return [classForToken("plain", prefix)];
+  return parts.map(
+    (_, index) => classForToken(parts.slice(0, index + 1).join("."), prefix)
+  );
+}
+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 themeId = normalizedThemeId.startsWith("yuirinx-") ? normalizedThemeId.slice("yuirinx-".length) : normalizedThemeId;
+  const preClasses = [
+    "yuirinx",
+    themeId ? `yuirinx-theme-${themeId}` : "",
+    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") {
+      const classes = classesForToken(token.type, prefix);
+      return `<span class="${escapeHtml(classes.join(" "))}">${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 themeId = normalizedThemeId.startsWith("yuirinx-") ? normalizedThemeId.slice("yuirinx-".length) : normalizedThemeId;
+  const rawSelector = options.selector ?? `.yuirinx-theme-${themeId || "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(";")}}`);
+  }
+  const tokenStyles = Object.entries(theme.tokens).sort(
+    ([left], [right]) => left.split(".").length - right.split(".").length
+  );
+  for (const [type, style] of tokenStyles) {
+    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");
+}
+export {
+  renderColorLines,
+  renderTokens,
+  resolveTokenStyle,
+  themeToCss
+};

package/dist/esm/core/tokenizer.js

@@ -0,0 +1,107 @@
+import { YuirinxError } from "./errors.js";
+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 = {
+        source: code,
+        language: grammar.id,
+        state: stateName,
+        stack: publicStack(grammar.id, stack),
+        offset
+      };
+      if (rule.when && !rule.when(match, context)) continue;
+      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;
+}
+export {
+  tokenizeCompiled
+};