reslop 0.1.4 → 0.1.6

package/lib/highlight/html.js

@@ -0,0 +1,90 @@
+'use strict';
+
+const { SQUOTE, emit, skipQuoted } = require('./core.js');
+
+const langs = ['html'];
+
+const aliases = { htm: 'html' };
+
+const colorHtmlTag = (tag) => {
+  const out = [];
+  let i = 1;
+  const n = tag.length;
+  emit(out, 'punct', '<');
+  if (tag[i] === '/') {
+    emit(out, 'punct', '/');
+    i += 1;
+  }
+  let j = i;
+  while (j < n && /[A-Za-z0-9:-]/.test(tag[j])) j += 1;
+  emit(out, 'tag', tag.slice(i, j));
+  i = j;
+  while (i < n) {
+    if (tag[i] === '>' || (tag[i] === '/' && tag[i + 1] === '>')) {
+      emit(out, 'punct', tag.slice(i));
+      break;
+    }
+    if (/\s/.test(tag[i])) {
+      emit(out, 'plain', tag[i]);
+      i += 1;
+      continue;
+    }
+    if (tag[i] === '"' || tag[i] === SQUOTE) {
+      const q = tag[i];
+      let k = i + 1;
+      while (k < n && tag[k] !== q) k += 1;
+      k = Math.min(k + 1, n);
+      emit(out, 'string', tag.slice(i, k));
+      i = k;
+      continue;
+    }
+    if (/[A-Za-z_:]/.test(tag[i])) {
+      let k = i + 1;
+      while (k < n && /[A-Za-z0-9_:.-]/.test(tag[k])) k += 1;
+      emit(out, 'attr', tag.slice(i, k));
+      i = k;
+      continue;
+    }
+    emit(out, 'punct', tag[i]);
+    i += 1;
+  }
+  return out;
+};
+
+const highlight = (source) => {
+  const out = [];
+  let i = 0;
+  const n = source.length;
+  while (i < n) {
+    if (source.startsWith('<!--', i)) {
+      let j = source.indexOf('-->', i + 4);
+      j = j === -1 ? n : j + 3;
+      emit(out, 'comment', source.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (source[i] === '<') {
+      let j = i + 1;
+      while (j < n && source[j] !== '>') {
+        if (source[j] === '"' || source[j] === SQUOTE) {
+          j = skipQuoted(source, j);
+          continue;
+        }
+        j += 1;
+      }
+      if (j < n) j += 1;
+      for (const t of colorHtmlTag(source.slice(i, j))) out.push(t);
+      i = j;
+      continue;
+    }
+    let j = i + 1;
+    while (j < n && source[j] !== '<' && !source.startsWith('<!--', j)) {
+      j += 1;
+    }
+    emit(out, 'plain', source.slice(i, j));
+    i = j;
+  }
+  return out;
+};
+
+module.exports = { langs, aliases, highlight };

package/lib/highlight/js.js

@@ -0,0 +1,571 @@
+'use strict';
+
+const hl = require('./core.js');
+const {
+  QUOTES,
+  EXPECT_STYLE,
+  emit,
+  tokensText,
+  wordStyle,
+  peekIdent,
+  skipWs,
+  readUntilNl,
+  readBlockComment,
+  readJsNumber,
+  readJsOperator,
+  readString,
+  readTemplateInterp,
+  styleConstant,
+  stylePascal,
+  styleCall,
+} = hl;
+
+const langs = ['js', 'mjs', 'ts', 'jsx', 'tsx'];
+
+const aliases = {
+  javascript: 'js',
+  typescript: 'ts',
+  cjs: 'js',
+  dts: 'ts',
+};
+
+const OPTIONS = {
+  js: {},
+  mjs: {},
+  ts: { ts: true },
+  jsx: { jsx: true },
+  tsx: { ts: true, jsx: true },
+};
+
+const STORAGE = [
+  'const',
+  'let',
+  'var',
+  'function',
+  'class',
+  'extends',
+  'static',
+  'async',
+  'get',
+  'set',
+  'constructor',
+  'new',
+  'typeof',
+  'instanceof',
+  'void',
+  'delete',
+  'yield',
+  'await',
+  'import',
+  'export',
+  'from',
+  'as',
+  'default',
+  'type',
+  'interface',
+  'implements',
+  'enum',
+  'namespace',
+  'module',
+  'declare',
+  'abstract',
+  'readonly',
+  'private',
+  'public',
+  'protected',
+  'override',
+  'satisfies',
+];
+
+const CONTROL = [
+  'if',
+  'else',
+  'for',
+  'while',
+  'do',
+  'switch',
+  'case',
+  'break',
+  'continue',
+  'return',
+  'throw',
+  'try',
+  'catch',
+  'finally',
+  'with',
+  'of',
+  'in',
+];
+
+const LITERALS = [
+  'true',
+  'false',
+  'null',
+  'undefined',
+  'NaN',
+  'Infinity',
+  'this',
+  'super',
+];
+
+const TYPES = [
+  'string',
+  'number',
+  'boolean',
+  'symbol',
+  'bigint',
+  'object',
+  'any',
+  'unknown',
+  'never',
+  'void',
+  'keyof',
+  'infer',
+  'unique',
+  'asserts',
+  'is',
+];
+
+const BUILTINS = [
+  'console',
+  'Math',
+  'JSON',
+  'Date',
+  'Array',
+  'Object',
+  'String',
+  'Number',
+  'Boolean',
+  'Map',
+  'Set',
+  'WeakMap',
+  'WeakSet',
+  'Promise',
+  'Error',
+  'RegExp',
+  'Symbol',
+  'Proxy',
+  'Reflect',
+  'Intl',
+  'Buffer',
+  'process',
+  'module',
+  'exports',
+  'require',
+  'global',
+  'globalThis',
+  'window',
+  'document',
+  'parseInt',
+  'parseFloat',
+  'isNaN',
+  'isFinite',
+  'encodeURI',
+  'decodeURI',
+  'encodeURIComponent',
+  'decodeURIComponent',
+  'setTimeout',
+  'setInterval',
+  'clearTimeout',
+  'clearInterval',
+  'fetch',
+  'URL',
+  'URLSearchParams',
+];
+
+const NEXT_EXPECT = {
+  function: 'function',
+  class: 'class',
+  interface: 'class',
+  enum: 'class',
+  type: 'type',
+};
+
+const typeOverlay = TYPES.filter((word) => STORAGE.includes(word));
+
+const WORD_STYLE = {
+  ...wordStyle(CONTROL, 'control'),
+  ...wordStyle(LITERALS, 'literal'),
+  ...wordStyle(BUILTINS, 'className'),
+  ...wordStyle(STORAGE, 'storage'),
+  ...wordStyle(typeOverlay, 'type'),
+};
+
+const TS_WORD_STYLE = {
+  ...WORD_STYLE,
+  ...wordStyle(TYPES, 'type'),
+};
+
+const plainTail = (out) => tokensText(out).slice(-8);
+
+const styleExpected = ({ expectName }) => EXPECT_STYLE[expectName];
+
+const styleKeyword = ({ word, ts }) => {
+  const table = ts ? TS_WORD_STYLE : WORD_STYLE;
+  if (!Object.hasOwn(table, word)) return null;
+  return table[word];
+};
+
+const styleAssign = ({ after, source, k }) => {
+  if (after !== '=') return null;
+  const k2 = skipWs(source, k + 1);
+  const rhs = source.slice(k2, k2 + 8);
+  if (rhs.startsWith('async')) return 'function';
+  if (rhs.startsWith('function')) return 'function';
+  if (source[k2] === '(') return 'function';
+  return 'variable';
+};
+
+const styleProperty = ({ out }) => {
+  const prev = plainTail(out);
+  return /\.$/.test(prev) ? 'property' : null;
+};
+
+const IDENT_RULES = [
+  styleExpected,
+  styleKeyword,
+  styleConstant,
+  stylePascal,
+  styleCall,
+  styleAssign,
+  styleProperty,
+];
+
+const identStyle = (ctx) => {
+  for (const rule of IDENT_RULES) {
+    const style = rule(ctx);
+    if (style) return style;
+  }
+  return 'variable';
+};
+
+const readRegex = (source, i) => {
+  let j = i + 1;
+  const n = source.length;
+  while (j < n) {
+    if (source[j] === '\\') {
+      j += 2;
+      continue;
+    }
+    if (source[j] === '[') {
+      j += 1;
+      while (j < n && source[j] !== ']') {
+        if (source[j] === '\\') j += 1;
+        j += 1;
+      }
+      j += 1;
+      continue;
+    }
+    if (source[j] === '/') {
+      j += 1;
+      while (j < n && /[a-z]/i.test(source[j])) j += 1;
+      break;
+    }
+    if (source[j] === '\n') break;
+    j += 1;
+  }
+  return { text: source.slice(i, j), end: j };
+};
+
+const isRegexContext = (out) => {
+  const prev = tokensText(out).trimEnd();
+  if (!prev) return true;
+  const afterOperator = /[=(:,[?!&|{};]$/.test(prev);
+  const afterKeyword = /(?:return|case|throw|=>|typeof|void)$/.test(prev);
+  return afterOperator || afterKeyword;
+};
+
+const highlightTemplate = (source, i, highlightExpr) => {
+  const n = source.length;
+  let j = i + 1;
+  const parts = [];
+  emit(parts, 'template', '`');
+  let buf = '';
+  const flush = () => {
+    if (buf) {
+      emit(parts, 'template', buf);
+      buf = '';
+    }
+  };
+  while (j < n) {
+    if (source[j] === '\\') {
+      flush();
+      emit(parts, 'escape', source.slice(j, j + 2));
+      j += 2;
+      continue;
+    }
+    if (source[j] === '`') {
+      flush();
+      emit(parts, 'template', '`');
+      j += 1;
+      break;
+    }
+    if (source[j] === '$' && source[j + 1] === '{') {
+      flush();
+      emit(parts, 'interpolation', '${');
+      j += 2;
+      const interp = readTemplateInterp(source, j);
+      const inner = highlightExpr(interp.expr);
+      for (const t of inner) parts.push(t);
+      j = interp.end;
+      if (source[j] === '}') {
+        emit(parts, 'interpolation', '}');
+        j += 1;
+      }
+      continue;
+    }
+    buf += source[j];
+    j += 1;
+  }
+  flush();
+  return { tokens: parts, end: j };
+};
+
+const isJsxTagStart = (source, i) => {
+  if (source[i] !== '<') return false;
+  if (i > 0 && /[A-Za-z0-9_$]/.test(source[i - 1])) return false;
+  const next = source[i + 1];
+  if (next === '>' || next === '/') return true;
+  if (!/[A-Za-z_$]/.test(next || '')) return false;
+  let j = i + 1;
+  while (j < source.length && /[A-Za-z0-9_$.:-]/.test(source[j])) j += 1;
+  const after = source[skipWs(source, j)];
+  if (after === '>' || after === '/' || after === '{') return true;
+  return /[A-Za-z_$]/.test(after || '');
+};
+
+const jsxNameStyle = (name) => {
+  if (/^[A-Z]/.test(name) || name.includes('.')) return 'className';
+  return 'tag';
+};
+
+const readJsxName = (source, i) => {
+  let j = i;
+  while (j < source.length && /[A-Za-z0-9_$.:-]/.test(source[j])) j += 1;
+  return { text: source.slice(i, j), end: j };
+};
+
+const highlightJsxExpr = (source, i, inner) => {
+  const out = [];
+  emit(out, 'interpolation', '{');
+  const interp = readTemplateInterp(source, i + 1);
+  const tokens = inner(interp.expr);
+  for (const t of tokens) out.push(t);
+  let end = interp.end;
+  if (source[end] === '}') {
+    emit(out, 'interpolation', '}');
+    end += 1;
+  }
+  return { tokens: out, end };
+};
+
+const highlightJsxTagTail = (source, i, inner, out) => {
+  const n = source.length;
+  let selfClosing = false;
+  while (i < n) {
+    const ch = source[i];
+    if (ch === '>') {
+      emit(out, 'punct', '>');
+      i += 1;
+      break;
+    }
+    if (ch === '/' && source[i + 1] === '>') {
+      emit(out, 'punct', '/>');
+      i += 2;
+      selfClosing = true;
+      break;
+    }
+    if (/\s/.test(ch)) {
+      emit(out, 'plain', ch);
+      i += 1;
+      continue;
+    }
+    if (ch === '{') {
+      const expr = highlightJsxExpr(source, i, inner);
+      for (const t of expr.tokens) out.push(t);
+      i = expr.end;
+      continue;
+    }
+    if (QUOTES.includes(ch)) {
+      const { text, end } = readString(source, i);
+      emit(out, 'string', text);
+      i = end;
+      continue;
+    }
+    if (ch === '=') {
+      emit(out, 'punct', '=');
+      i += 1;
+      continue;
+    }
+    if (/[A-Za-z_$]/.test(ch)) {
+      const { text, end } = readJsxName(source, i);
+      emit(out, 'attr', text);
+      i = end;
+      continue;
+    }
+    emit(out, 'punct', ch);
+    i += 1;
+  }
+  return { end: i, selfClosing };
+};
+
+const highlightJsxElement = (source, i, inner) => {
+  const out = [];
+  const n = source.length;
+  emit(out, 'punct', '<');
+  i += 1;
+  let closing = false;
+  if (source[i] === '/') {
+    emit(out, 'punct', '/');
+    i += 1;
+    closing = true;
+  }
+  const nameRead = readJsxName(source, i);
+  const name = nameRead.text;
+  if (name) {
+    emit(out, jsxNameStyle(name), name);
+    i = nameRead.end;
+  }
+  const tail = highlightJsxTagTail(source, i, inner, out);
+  i = tail.end;
+  if (closing || tail.selfClosing) return { tokens: out, end: i };
+  while (i < n) {
+    if (source.startsWith('</', i)) {
+      const close = highlightJsxElement(source, i, inner);
+      for (const t of close.tokens) out.push(t);
+      return { tokens: out, end: close.end };
+    }
+    if (source[i] === '{') {
+      const expr = highlightJsxExpr(source, i, inner);
+      for (const t of expr.tokens) out.push(t);
+      i = expr.end;
+      continue;
+    }
+    if (source[i] === '<' && isJsxTagStart(source, i)) {
+      const child = highlightJsxElement(source, i, inner);
+      for (const t of child.tokens) out.push(t);
+      i = child.end;
+      continue;
+    }
+    let j = i;
+    while (j < n && source[j] !== '<' && source[j] !== '{') j += 1;
+    if (j === i) {
+      emit(out, 'plain', source[i]);
+      i += 1;
+      continue;
+    }
+    emit(out, 'plain', source.slice(i, j));
+    i = j;
+  }
+  return { tokens: out, end: i };
+};
+
+const highlightJsFamily = (source, options = {}) => {
+  const ts = options.ts === true;
+  const jsx = options.jsx === true;
+  const inner = (expr) => highlightJsFamily(expr, options);
+  const out = [];
+  let i = 0;
+  const n = source.length;
+  let expectName = null;
+
+  while (i < n) {
+    const ch = source[i];
+    const next = source[i + 1];
+
+    if (ch === '/' && next === '/') {
+      const { text, end } = readUntilNl(source, i);
+      emit(out, 'comment', text);
+      i = end;
+      continue;
+    }
+
+    if (ch === '/' && next === '*') {
+      const { text, end } = readBlockComment(source, i);
+      emit(out, 'comment', text);
+      i = end;
+      continue;
+    }
+
+    if (ch === '`') {
+      const r = highlightTemplate(source, i, inner);
+      for (const t of r.tokens) out.push(t);
+      i = r.end;
+      continue;
+    }
+
+    if (QUOTES.includes(ch)) {
+      const { text, end } = readString(source, i);
+      emit(out, 'string', text);
+      i = end;
+      continue;
+    }
+
+    if (ch === '/' && isRegexContext(out)) {
+      const { text, end } = readRegex(source, i);
+      emit(out, 'regex', text);
+      i = end;
+      continue;
+    }
+
+    if (/[0-9]/.test(ch) || (ch === '.' && /[0-9]/.test(next || ''))) {
+      const { text, end } = readJsNumber(source, i);
+      emit(out, 'number', text);
+      i = end;
+      continue;
+    }
+
+    if (ch === '@') {
+      let j = i + 1;
+      while (j < n && /[A-Za-z0-9_$]/.test(source[j])) j += 1;
+      emit(out, 'decorator', source.slice(i, j));
+      i = j;
+      expectName = null;
+      continue;
+    }
+
+    if (/[A-Za-z_$]/.test(ch)) {
+      const word = peekIdent(source, i);
+      const end = i + word.length;
+      const k = skipWs(source, end);
+      const after = source[k];
+      const ctx = { word, ts, after, source, k, out, expectName };
+      emit(out, identStyle(ctx), word);
+      if (EXPECT_STYLE[expectName]) expectName = null;
+      else expectName = NEXT_EXPECT[word] ?? null;
+      i = end;
+      continue;
+    }
+
+    if (jsx && ch === '<' && isJsxTagStart(source, i)) {
+      const node = highlightJsxElement(source, i, inner);
+      for (const t of node.tokens) out.push(t);
+      i = node.end;
+      expectName = null;
+      continue;
+    }
+
+    if (/[=<>!+\-*/%&|^~?:]/.test(ch)) {
+      const { text, end } = readJsOperator(source, i);
+      emit(out, 'operator', text);
+      i = end;
+      expectName = null;
+      continue;
+    }
+    if (/[{}()[\];,.]/.test(ch)) {
+      emit(out, 'punct', ch);
+      i += 1;
+      continue;
+    }
+    emit(out, 'plain', ch);
+    i += 1;
+  }
+  return out;
+};
+
+const highlight = (source, lang) => {
+  const options = OPTIONS[lang] ?? {};
+  return highlightJsFamily(source, options);
+};
+
+module.exports = { langs, aliases, highlight };

package/lib/highlight/json.js

@@ -0,0 +1,54 @@
+'use strict';
+
+const { emit, readString } = require('./core.js');
+
+const langs = ['json'];
+
+const JSON_LITERAL = {
+  true: 'literal',
+  false: 'literal',
+  null: 'literal',
+};
+
+const highlight = (source) => {
+  const out = [];
+  let i = 0;
+  const n = source.length;
+  while (i < n) {
+    const ch = source[i];
+    if (ch === '"') {
+      const { text, end } = readString(source, i);
+      let k = end;
+      while (k < n && /\s/.test(source[k])) k += 1;
+      const kind = source[k] === ':' ? 'property' : 'string';
+      emit(out, kind, text);
+      i = end;
+      continue;
+    }
+    if (/[0-9-]/.test(ch)) {
+      let j = i;
+      while (j < n && /[0-9.eE+-]/.test(source[j])) j += 1;
+      emit(out, 'number', source.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (/[a-z]/.test(ch)) {
+      let j = i;
+      while (j < n && /[a-z]/.test(source[j])) j += 1;
+      const word = source.slice(i, j);
+      emit(out, JSON_LITERAL[word] ?? 'plain', word);
+      i = j;
+      continue;
+    }
+    if (/[{}[\],:]/.test(ch)) {
+      emit(out, 'punct', ch);
+      i += 1;
+      continue;
+    }
+    emit(out, 'plain', ch);
+    i += 1;
+  }
+  return out;
+};
+
+module.exports = { langs, highlight };