@wdprlib/render 2.0.0 → 3.0.0

package/src/libs/highlighter/engine/keywords.ts

@@ -0,0 +1,22 @@
+import type { LanguageDefinition } from "../types";
+
+export function resolveKeywordClass(
+  def: LanguageDefinition,
+  state: number,
+  patternIndex: number,
+  matchStr: string,
+  fallback: string,
+): string {
+  let kwDef = def.keywords[state]?.[patternIndex];
+  if (!kwDef || kwDef === -1 || typeof kwDef !== "object" || Object.keys(kwDef).length === 0) {
+    kwDef = def.keywords[-1]?.[patternIndex];
+  }
+  if (kwDef && kwDef !== -1 && typeof kwDef === "object") {
+    for (const [group, re] of Object.entries(kwDef)) {
+      if ((re as RegExp).test(matchStr)) {
+        return def.kwmap[group] ?? fallback;
+      }
+    }
+  }
+  return fallback;
+}

package/src/libs/highlighter/engine/parts.ts

@@ -0,0 +1,36 @@
+import type { HighlightToken } from "./token";
+
+export function buildPartTokens(
+  str: string,
+  match: RegExpExecArray,
+  partDef: Record<number, string>,
+  captureIndex: number,
+  count: number,
+  groupStart: number,
+  matchStr: string,
+  inner: string,
+): HighlightToken[] {
+  const parts: HighlightToken[] = [];
+  let partpos = groupStart;
+  for (let j = 1; j <= count; j++) {
+    const subIdx = j + captureIndex;
+    if (subIdx >= match.length || match[subIdx] == null || match[subIdx] === "") continue;
+    const subStr = match[subIdx]!;
+    const subStart = str.indexOf(subStr, partpos);
+    if (subStart < 0) continue;
+    if (partDef[j]) {
+      if (subStart > partpos) {
+        parts.unshift({ class: inner, content: str.substring(partpos, subStart) });
+      }
+      parts.unshift({ class: partDef[j]!, content: subStr });
+    }
+    partpos = subStart + subStr.length;
+  }
+  if (partpos < groupStart + matchStr.length) {
+    parts.unshift({
+      class: inner,
+      content: str.substring(partpos, groupStart + matchStr.length),
+    });
+  }
+  return parts;
+}

package/src/libs/highlighter/engine/preprocess.ts

@@ -0,0 +1,10 @@
+/**
+ * Preprocess source code the same way Text_Highlighter's HTML renderer does.
+ */
+export function preprocessHighlightInput(input: string): string {
+  return input
+    .replace(/\r\n/g, "\n")
+    .replace(/^$/gm, " ")
+    .replace(/\t/g, "    ")
+    .replace(/\s+$/, "");
+}

package/src/libs/highlighter/engine/render.ts

@@ -0,0 +1,31 @@
+import { escapeHighlightHtml } from "./html";
+import type { HighlightToken } from "./token";
+
+/**
+ * Render an array of tokens to HTML with `hl-*` class spans.
+ */
+export function renderTokens(tokens: HighlightToken[]): string {
+  if (tokens.length === 0) return "";
+
+  let html = "";
+  let lastClass = "";
+
+  for (const token of tokens) {
+    if (token.content.length === 0) continue;
+    const escaped = escapeHighlightHtml(token.content);
+    if (token.class !== lastClass) {
+      if (lastClass) {
+        html += "</span>";
+      }
+      html += `<span class="hl-${token.class}">`;
+      lastClass = token.class;
+    }
+    html += escaped;
+  }
+
+  if (lastClass) {
+    html += "</span>";
+  }
+
+  return `<div class="hl-main"><pre>${html}</pre></div>`;
+}

package/src/libs/highlighter/engine/token.ts

@@ -0,0 +1,7 @@
+/** A single highlighted token with its CSS class and text content. */
+export interface HighlightToken {
+  /** CSS class name suffix (used as `hl-{class}`). */
+  class: string;
+  /** The literal text content of this token. */
+  content: string;
+}

package/src/libs/highlighter/engine/tokenizer.ts

@@ -0,0 +1,266 @@
+import type { LanguageDefinition } from "../types";
+import { buildEndPattern } from "./end-pattern";
+import { resolveKeywordClass } from "./keywords";
+import { buildPartTokens } from "./parts";
+import { preprocessHighlightInput } from "./preprocess";
+import type { HighlightToken } from "./token";
+import { findGroupPosition } from "./utils";
+
+interface HighlighterState {
+  state: number;
+  lastdelim: string;
+  lastinner: string;
+  endpattern: RegExp | null;
+}
+
+/**
+ * Tokenize source code using a language definition's state machine.
+ */
+export function tokenize(def: LanguageDefinition, input: string): HighlightToken[] {
+  const str = preprocessHighlightInput(input);
+  const len = str.length;
+  if (len === 0) return [];
+
+  let state = -1;
+  let pos = 0;
+  let lastinner = def.defClass;
+  let lastdelim = def.defClass;
+  let endpattern: RegExp | null = null;
+  const stateStack: HighlighterState[] = [];
+  const tokenStack: HighlightToken[] = [];
+  const result: HighlightToken[] = [];
+
+  function getToken(): HighlightToken | null {
+    if (tokenStack.length > 0) {
+      return tokenStack.pop()!;
+    }
+    if (pos >= len) {
+      return null;
+    }
+
+    const endStateMatch = findEndStateMatch(str, pos, state, endpattern);
+    const token = matchStateToken({
+      def,
+      str,
+      pos,
+      state,
+      lastinner,
+      lastdelim,
+      endpattern,
+      stateStack,
+      tokenStack,
+      endStateMatch,
+      setPosition: (nextPos) => {
+        pos = nextPos;
+      },
+      setState: (next) => {
+        state = next.state;
+        lastinner = next.lastinner;
+        lastdelim = next.lastdelim;
+        endpattern = next.endpattern;
+      },
+    });
+    if (token) {
+      return token;
+    }
+
+    if (endStateMatch.endpos > -1) {
+      tokenStack.push({ class: lastdelim, content: endStateMatch.endmatch });
+      if (endStateMatch.endpos > pos) {
+        tokenStack.push({ class: lastinner, content: str.substring(pos, endStateMatch.endpos) });
+      }
+      const prev = stateStack.pop()!;
+      state = prev.state;
+      lastdelim = prev.lastdelim;
+      lastinner = prev.lastinner;
+      endpattern = prev.endpattern;
+      pos = endStateMatch.endpos + endStateMatch.endmatch.length;
+      if (tokenStack.length > 0) {
+        return tokenStack.pop()!;
+      }
+      return getToken();
+    }
+
+    const p = pos;
+    pos = len;
+    return { class: lastinner, content: str.substring(p) };
+  }
+
+  let token: HighlightToken | null;
+  while ((token = getToken()) !== null) {
+    result.push(token);
+  }
+
+  return result;
+}
+
+interface EndStateMatch {
+  endpos: number;
+  endmatch: string;
+}
+
+function findEndStateMatch(
+  str: string,
+  pos: number,
+  state: number,
+  endpattern: RegExp | null,
+): EndStateMatch {
+  if (state === -1 || !endpattern) {
+    return { endpos: -1, endmatch: "" };
+  }
+
+  endpattern.lastIndex = pos;
+  const match = endpattern.exec(str);
+  return match ? { endpos: match.index, endmatch: match[0] } : { endpos: -1, endmatch: "" };
+}
+
+interface MatchStateTokenArgs {
+  def: LanguageDefinition;
+  str: string;
+  pos: number;
+  state: number;
+  lastinner: string;
+  lastdelim: string;
+  endpattern: RegExp | null;
+  stateStack: HighlighterState[];
+  tokenStack: HighlightToken[];
+  endStateMatch: EndStateMatch;
+  setPosition(pos: number): void;
+  setState(state: HighlighterState): void;
+}
+
+function matchStateToken(args: MatchStateTokenArgs): HighlightToken | null {
+  const reg = args.def.regs[args.state];
+  if (!reg) return null;
+
+  reg.lastIndex = args.pos;
+  const match = reg.exec(args.str);
+  if (!match) return null;
+
+  const countsArr = args.def.counts[args.state]!;
+  let captureIndex = 1;
+
+  for (let patternIndex = 0; patternIndex < countsArr.length; patternIndex++) {
+    const count = countsArr[patternIndex]!;
+    if (captureIndex >= match.length) break;
+
+    if (
+      match[captureIndex] != null &&
+      (args.endStateMatch.endpos === -1 || match.index < args.endStateMatch.endpos)
+    ) {
+      return emitMatchedPattern(args, match, patternIndex, captureIndex, count);
+    }
+
+    captureIndex += count + 1;
+  }
+
+  return null;
+}
+
+function emitMatchedPattern(
+  args: MatchStateTokenArgs,
+  match: RegExpExecArray,
+  patternIndex: number,
+  captureIndex: number,
+  count: number,
+): HighlightToken {
+  const statesArr = args.def.states[args.state]!;
+  const delimArr = args.def.delim[args.state]!;
+  const matchStart = match.index;
+  const matchStr = match[captureIndex]!;
+  const groupStart = findGroupPosition(args.str, match, captureIndex, matchStart);
+
+  if (statesArr[patternIndex] !== -1) {
+    args.tokenStack.push({ class: delimArr[patternIndex]!, content: matchStr });
+  } else {
+    pushNonTransitionTokens(args, match, patternIndex, captureIndex, count, groupStart, matchStr);
+  }
+
+  if (groupStart > args.pos) {
+    args.tokenStack.push({
+      class: args.lastinner,
+      content: args.str.substring(args.pos, groupStart),
+    });
+  }
+
+  args.setPosition(groupStart + matchStr.length);
+
+  if (statesArr[patternIndex] !== -1) {
+    enterState(args, match, patternIndex, captureIndex, count);
+  }
+
+  return args.tokenStack.pop()!;
+}
+
+function pushNonTransitionTokens(
+  args: MatchStateTokenArgs,
+  match: RegExpExecArray,
+  patternIndex: number,
+  captureIndex: number,
+  count: number,
+  groupStart: number,
+  matchStr: string,
+): void {
+  let inner = args.def.inner[args.state]![patternIndex]!;
+  const partDef = args.def.parts[args.state]?.[patternIndex];
+  if (partDef) {
+    pushPartTokens(args, match, partDef, captureIndex, count, groupStart, matchStr, inner);
+    return;
+  }
+
+  inner = resolveKeywordClass(args.def, args.state, patternIndex, matchStr, inner);
+  args.tokenStack.push({ class: inner, content: matchStr });
+}
+
+function pushPartTokens(
+  args: MatchStateTokenArgs,
+  match: RegExpExecArray,
+  partDef: Record<number, string>,
+  captureIndex: number,
+  count: number,
+  groupStart: number,
+  matchStr: string,
+  inner: string,
+): void {
+  const parts: HighlightToken[] = [];
+  parts.push(
+    ...buildPartTokens(args.str, match, partDef, captureIndex, count, groupStart, matchStr, inner),
+  );
+  args.tokenStack.push(...parts);
+}
+
+function enterState(
+  args: MatchStateTokenArgs,
+  match: RegExpExecArray,
+  patternIndex: number,
+  captureIndex: number,
+  count: number,
+): void {
+  const statesArr = args.def.states[args.state]!;
+  const delimArr = args.def.delim[args.state]!;
+  const innerArr = args.def.inner[args.state]!;
+  args.stateStack.push({
+    state: args.state,
+    lastdelim: args.lastdelim,
+    lastinner: args.lastinner,
+    endpattern: args.endpattern,
+  });
+
+  const prevState = args.state;
+  const nextState = statesArr[patternIndex]!;
+  const endRe = args.def.end[nextState];
+  args.setState({
+    state: nextState,
+    lastinner: innerArr[patternIndex]!,
+    lastdelim: delimArr[patternIndex]!,
+    endpattern: buildEndPattern(
+      args.def,
+      prevState,
+      patternIndex,
+      count,
+      captureIndex,
+      match,
+      endRe ?? undefined,
+    ),
+  });
+}

package/src/libs/highlighter/engine/utils.ts

@@ -0,0 +1,38 @@
+/**
+ * Find the actual position of capture group `n` within the source string.
+ */
+export function findGroupPosition(
+  str: string,
+  match: RegExpExecArray,
+  groupIndex: number,
+  matchStart: number,
+): number {
+  const groupStr = match[groupIndex]!;
+  const idx = str.indexOf(groupStr, matchStart);
+  return idx >= 0 ? idx : matchStart;
+}
+
+/**
+ * Escape regex special characters in a string for safe use in `new RegExp()`.
+ */
+export function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+/**
+ * Swap bracket characters to their matching counterparts.
+ */
+export function matchingBrackets(str: string): string {
+  return str.replace(/[()<>[\]{}]/g, (char) => MATCHING_BRACKETS[char] ?? char);
+}
+
+const MATCHING_BRACKETS: Record<string, string> = {
+  "(": ")",
+  ")": "(",
+  "<": ">",
+  ">": "<",
+  "[": "]",
+  "]": "[",
+  "{": "}",
+  "}": "{",
+};

package/src/libs/highlighter/index.ts

@@ -0,0 +1,70 @@
+/**
+ *
+ * TypeScript port of PEAR Text_Highlighter 0.5.1 for server-side
+ * syntax highlighting of `[[code]]` blocks.
+ *
+ * Supports the same languages as Wikidot's original PHP implementation:
+ * CSS, C++, Diff, DTD, HTML, Java, JavaScript, PHP, Python, Ruby, SQL,
+ * and XML. Perl is excluded because its definition relies on PCRE-only
+ * regex features.
+ *
+ * Original: http://pear.php.net/package/Text_Highlighter
+ * Author: Andrey Demenev <demenev@on-line.jar.ru>
+ * Copyright: 2004 Andrey Demenev
+ * License: PHP License 3.0 (http://www.php.net/license/3_0.txt)
+ *
+ * @module
+ */
+
+import type { LanguageDefinition } from "./types";
+import { tokenize, renderTokens } from "./engine";
+import { cssLang } from "./languages/css";
+import { cppLang } from "./languages/cpp";
+import { diffLang } from "./languages/diff";
+import { dtdLang } from "./languages/dtd";
+import { htmlLang } from "./languages/html";
+import { javaLang } from "./languages/java";
+import { javascriptLang } from "./languages/javascript";
+import { phpLang } from "./languages/php";
+import { pythonLang } from "./languages/python";
+import { rubyLang } from "./languages/ruby";
+import { sqlLang } from "./languages/sql";
+import { xmlLang } from "./languages/xml";
+
+/**
+ * Registry of supported language definitions, keyed by lowercase name.
+ *
+ * `xhtml` is aliased to `html` (they share the same definition).
+ */
+const LANGUAGES: Record<string, LanguageDefinition> = {
+  css: cssLang,
+  cpp: cppLang,
+  diff: diffLang,
+  dtd: dtdLang,
+  html: htmlLang,
+  java: javaLang,
+  javascript: javascriptLang,
+  // perl: excluded (PCRE-only features)
+  php: phpLang,
+  python: pythonLang,
+  ruby: rubyLang,
+  sql: sqlLang,
+  xml: xmlLang,
+  xhtml: htmlLang,
+};
+
+/**
+ * Highlight source code using the Text_Highlighter-compatible engine.
+ *
+ * @param code - Raw source code to highlight.
+ * @param language - Programming language name (case-insensitive).
+ * @returns HTML string with `hl-*` class spans wrapped in
+ *   `<div class="hl-main"><pre>...</pre></div>`, or `null` if the
+ *   language is not supported.
+ */
+export function highlight(code: string, language: string): string | null {
+  const def = LANGUAGES[language.toLowerCase()];
+  if (!def) return null;
+  const tokens = tokenize(def, code);
+  return renderTokens(tokens);
+}