reslop 0.1.4 → 0.1.6

package/lib/highlight/core.js

@@ -0,0 +1,194 @@
+'use strict';
+
+const SQUOTE = '\x27';
+const QUOTES = `${SQUOTE}"`;
+const ANY_QUOTE = `${QUOTES}\``;
+
+const OP3 = ['===', '!==', '>>>', '**=', '&&=', '||=', '??='];
+
+const OP2 = [
+  '==',
+  '!=',
+  '<=',
+  '>=',
+  '&&',
+  '||',
+  '??',
+  '=>',
+  '++',
+  '--',
+  '<<',
+  '>>',
+  '**',
+  '+=',
+  '-=',
+  '*=',
+  '/=',
+  '%=',
+  '&=',
+  '|=',
+  '^=',
+];
+
+const EXPECT_STYLE = {
+  function: 'function',
+  class: 'className',
+  type: 'className',
+};
+
+const emit = (out, style, text) => {
+  if (!text) return;
+  out.push({ text, style: style || 'plain' });
+};
+
+const tokensText = (out) => {
+  let s = '';
+  for (const t of out) s += t.text;
+  return s;
+};
+
+const wordStyle = (words, style) => {
+  const table = {};
+  for (const word of words) table[word] = style;
+  return table;
+};
+
+const peekIdent = (source, i) => {
+  if (!/[A-Za-z_$]/.test(source[i] || '')) return null;
+  let j = i + 1;
+  while (j < source.length && /[A-Za-z0-9_$]/.test(source[j])) j += 1;
+  return source.slice(i, j);
+};
+
+const skipWs = (source, i) => {
+  while (i < source.length && /\s/.test(source[i])) i += 1;
+  return i;
+};
+
+const readUntilNl = (source, i) => {
+  let j = i;
+  const n = source.length;
+  while (j < n && source[j] !== '\n') j += 1;
+  return { text: source.slice(i, j), end: j };
+};
+
+const readBlockComment = (source, i) => {
+  let j = i + 2;
+  const n = source.length;
+  while (j < n && !(source[j] === '*' && source[j + 1] === '/')) {
+    j += 1;
+  }
+  j = Math.min(j + 2, n);
+  return { text: source.slice(i, j), end: j };
+};
+
+const skipQuoted = (source, j) => {
+  const q = source[j];
+  j += 1;
+  const n = source.length;
+  while (j < n && source[j] !== q) {
+    if (source[j] === '\\') j += 1;
+    j += 1;
+  }
+  j += 1;
+  return j;
+};
+
+const readJsNumber = (source, i) => {
+  const n = source.length;
+  let j = i;
+  if (source.startsWith('0x', i) || source.startsWith('0X', i)) {
+    j += 2;
+    while (j < n && /[0-9a-fA-F_]/.test(source[j])) j += 1;
+  } else if (source.startsWith('0b', i) || source.startsWith('0B', i)) {
+    j += 2;
+    while (j < n && /[01_]/.test(source[j])) j += 1;
+  } else if (source.startsWith('0o', i) || source.startsWith('0O', i)) {
+    j += 2;
+    while (j < n && /[0-7_]/.test(source[j])) j += 1;
+  } else {
+    while (j < n && /[0-9_n.]/.test(source[j])) j += 1;
+    if ('eE'.includes(source[j])) {
+      j += 1;
+      if ('+-'.includes(source[j])) j += 1;
+      while (j < n && /[0-9_]/.test(source[j])) j += 1;
+    }
+  }
+  return { text: source.slice(i, j), end: j };
+};
+
+const readJsOperator = (source, i) => {
+  const two = source.slice(i, i + 2);
+  const three = source.slice(i, i + 3);
+  let j = i + 1;
+  if (OP3.includes(three)) j = i + 3;
+  else if (OP2.includes(two)) j = i + 2;
+  return { text: source.slice(i, j), end: j };
+};
+
+const readString = (source, i) => {
+  const q = source[i];
+  let j = i + 1;
+  const n = source.length;
+  while (j < n) {
+    if (source[j] === '\\') {
+      j += 2;
+      continue;
+    }
+    if (source[j] === q) {
+      j += 1;
+      break;
+    }
+    if (source[j] === '\n') break;
+    j += 1;
+  }
+  return { text: source.slice(i, j), end: j };
+};
+
+const readTemplateInterp = (source, j) => {
+  let depth = 1;
+  const start = j;
+  const n = source.length;
+  while (j < n && depth > 0) {
+    if (ANY_QUOTE.includes(source[j])) {
+      j = skipQuoted(source, j);
+      continue;
+    }
+    if (source[j] === '{') depth += 1;
+    if (source[j] === '}') {
+      depth -= 1;
+      if (depth === 0) break;
+    }
+    j += 1;
+  }
+  return { expr: source.slice(start, j), end: j };
+};
+
+const styleConstant = ({ word }) =>
+  /^[A-Z][A-Z0-9_]+$/.test(word) ? 'constant' : null;
+
+const stylePascal = ({ word }) => (/^[A-Z]/.test(word) ? 'className' : null);
+
+const styleCall = ({ after }) => (after === '(' ? 'function' : null);
+
+module.exports = {
+  SQUOTE,
+  QUOTES,
+  ANY_QUOTE,
+  EXPECT_STYLE,
+  emit,
+  tokensText,
+  wordStyle,
+  peekIdent,
+  skipWs,
+  readUntilNl,
+  readBlockComment,
+  skipQuoted,
+  readJsNumber,
+  readJsOperator,
+  readString,
+  readTemplateInterp,
+  styleConstant,
+  stylePascal,
+  styleCall,
+};

package/lib/highlight/css.js

@@ -0,0 +1,76 @@
+'use strict';
+
+const { QUOTES, emit, readBlockComment, readString } = require('./core.js');
+
+const langs = ['css'];
+
+const CSS_NEXT_STYLE = {
+  ':': 'property',
+  '{': 'tag',
+};
+
+const cssWordStyle = (next) => CSS_NEXT_STYLE[next] ?? 'plain';
+
+const highlight = (source) => {
+  const out = [];
+  let i = 0;
+  const n = source.length;
+  while (i < n) {
+    const ch = source[i];
+    const next = source[i + 1];
+    if (ch === '/' && next === '*') {
+      const { text, end } = readBlockComment(source, i);
+      emit(out, 'comment', text);
+      i = end;
+      continue;
+    }
+    if (QUOTES.includes(ch)) {
+      const { text, end } = readString(source, i);
+      emit(out, 'string', text);
+      i = end;
+      continue;
+    }
+    if (ch === '@') {
+      let j = i + 1;
+      while (j < n && /[A-Za-z0-9-]/.test(source[j])) j += 1;
+      emit(out, 'keyword', source.slice(i, j));
+      i = j;
+      continue;
+    }
+    if ('#.'.includes(ch)) {
+      let j = i + 1;
+      while (j < n && /[A-Za-z0-9_-]/.test(source[j])) j += 1;
+      const kind = ch === '#' ? 'constant' : 'className';
+      emit(out, kind, source.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (/[0-9]/.test(ch)) {
+      let j = i;
+      while (j < n && /[0-9.%]/.test(source[j])) j += 1;
+      emit(out, 'number', source.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (/[A-Za-z_-]/.test(ch)) {
+      let j = i + 1;
+      while (j < n && /[A-Za-z0-9_-]/.test(source[j])) j += 1;
+      const word = source.slice(i, j);
+      let k = j;
+      while (k < n && /\s/.test(source[k])) k += 1;
+      emit(out, cssWordStyle(source[k]), 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 };

package/lib/highlight/csv.js

@@ -0,0 +1,66 @@
+'use strict';
+
+const { emit } = require('./core.js');
+
+const langs = ['csv'];
+
+const splitCsv = (line) => {
+  const cells = [];
+  let cur = '';
+  let inQ = false;
+  for (let i = 0; i < line.length; i += 1) {
+    const ch = line[i];
+    if (ch === '"') {
+      if (inQ && line[i + 1] === '"') {
+        cur += '"';
+        i += 1;
+      } else {
+        inQ = !inQ;
+        cur += ch;
+      }
+      continue;
+    }
+    if (ch === ',' && !inQ) {
+      cells.push(cur);
+      cur = '';
+      continue;
+    }
+    cur += ch;
+  }
+  cells.push(cur);
+  return cells;
+};
+
+const highlightCsvCell = (cell, row, col) => {
+  if (row === 0) return { text: cell, style: 'function' };
+  const num = /^-?\d+(\.\d+)?$/.test(cell.trim());
+  if (num) return { text: cell, style: 'number' };
+  if (col % 2 === 0) return { text: cell, style: 'string' };
+  return { text: cell, style: 'variable' };
+};
+
+const highlightCsvLine = (line, row) => {
+  if (!line) return [];
+  const cells = splitCsv(line);
+  const out = [];
+  for (let col = 0; col < cells.length; col += 1) {
+    if (col) emit(out, 'punct', ',');
+    const cell = highlightCsvCell(cells[col], row, col);
+    emit(out, cell.style, cell.text);
+  }
+  return out;
+};
+
+const highlight = (source) => {
+  const lines = source.split(/\r?\n/);
+  const out = [];
+  for (let row = 0; row < lines.length; row += 1) {
+    if (row) emit(out, 'plain', '\n');
+    for (const t of highlightCsvLine(lines[row], row === 0 ? 1 : row)) {
+      out.push(t);
+    }
+  }
+  return out;
+};
+
+module.exports = { langs, highlight };

package/lib/highlight/dart.js

@@ -0,0 +1,261 @@
+'use strict';
+
+const {
+  SQUOTE,
+  QUOTES,
+  EXPECT_STYLE,
+  emit,
+  wordStyle,
+  peekIdent,
+  skipWs,
+  readUntilNl,
+  readBlockComment,
+  readJsNumber,
+  readJsOperator,
+  readTemplateInterp,
+  styleConstant,
+  stylePascal,
+  styleCall,
+} = require('./core.js');
+
+const langs = ['dart'];
+
+const STORAGE = [
+  'abstract',
+  'as',
+  'base',
+  'class',
+  'const',
+  'covariant',
+  'deferred',
+  'enum',
+  'export',
+  'extends',
+  'extension',
+  'external',
+  'factory',
+  'final',
+  'get',
+  'hide',
+  'implements',
+  'import',
+  'interface',
+  'late',
+  'library',
+  'mixin',
+  'on',
+  'operator',
+  'part',
+  'required',
+  'sealed',
+  'set',
+  'show',
+  'static',
+  'typedef',
+  'var',
+  'with',
+];
+
+const CONTROL = [
+  'assert',
+  'async',
+  'await',
+  'break',
+  'case',
+  'catch',
+  'continue',
+  'default',
+  'do',
+  'else',
+  'for',
+  'if',
+  'in',
+  'is',
+  'new',
+  'rethrow',
+  'return',
+  'switch',
+  'sync',
+  'throw',
+  'try',
+  'when',
+  'while',
+  'yield',
+];
+
+const LITERALS = ['true', 'false', 'null', 'this', 'super'];
+
+const TYPES = ['void', 'dynamic', 'Never', 'int', 'double', 'num', 'bool'];
+
+const NEXT_EXPECT = {
+  class: 'class',
+  mixin: 'class',
+  enum: 'class',
+  extension: 'class',
+  typedef: 'type',
+};
+
+const WORD_STYLE = {
+  ...wordStyle(CONTROL, 'control'),
+  ...wordStyle(LITERALS, 'literal'),
+  ...wordStyle(STORAGE, 'storage'),
+  ...wordStyle(TYPES, 'type'),
+};
+
+const dartStringOpen = (source, i) => {
+  let at = i;
+  const raw = source[i] === 'r';
+  if (raw) at = i + 1;
+  let quote = '';
+  const triple = SQUOTE.repeat(3);
+  const dtriple = '"'.repeat(3);
+  if (source.startsWith(triple, at) || source.startsWith(dtriple, at)) {
+    quote = source.slice(at, at + 3);
+  } else if (QUOTES.includes(source[at] || '')) {
+    quote = source[at];
+  }
+  if (!quote) return null;
+  return { raw, quote, body: at + quote.length };
+};
+
+const dartIdentStyle = (ctx) => {
+  const known = WORD_STYLE[ctx.word];
+  if (known) return known;
+  if (EXPECT_STYLE[ctx.expectName]) return EXPECT_STYLE[ctx.expectName];
+  if (styleConstant(ctx)) return 'constant';
+  if (stylePascal(ctx)) return 'className';
+  if (styleCall(ctx)) return 'function';
+  return 'variable';
+};
+
+const highlightDartString = (source, i, inner) => {
+  const open = dartStringOpen(source, i);
+  const n = source.length;
+  const parts = [];
+  emit(parts, 'string', source.slice(i, open.body));
+  let j = open.body;
+  let buf = '';
+  const flush = () => {
+    if (!buf) return;
+    emit(parts, 'string', buf);
+    buf = '';
+  };
+  const quote = open.quote;
+  while (j < n) {
+    if (!open.raw && source[j] === '\\') {
+      flush();
+      emit(parts, 'escape', source.slice(j, j + 2));
+      j += 2;
+      continue;
+    }
+    if (source.startsWith(quote, j)) {
+      flush();
+      emit(parts, 'string', quote);
+      j += quote.length;
+      break;
+    }
+    if (!open.raw && source[j] === '$') {
+      const next = source[j + 1];
+      if (next === '{') {
+        flush();
+        emit(parts, 'interpolation', '${');
+        j += 2;
+        const interp = readTemplateInterp(source, j);
+        for (const t of inner(interp.expr)) parts.push(t);
+        j = interp.end;
+        if (source[j] === '}') {
+          emit(parts, 'interpolation', '}');
+          j += 1;
+        }
+        continue;
+      }
+      if (/[A-Za-z_$]/.test(next || '')) {
+        flush();
+        const ident = peekIdent(source, j + 1);
+        emit(parts, 'interpolation', `$${ident}`);
+        j += 1 + ident.length;
+        continue;
+      }
+    }
+    if (quote.length === 1 && source[j] === '\n') break;
+    buf += source[j];
+    j += 1;
+  }
+  flush();
+  return { tokens: parts, end: j };
+};
+
+const highlight = (source) => {
+  const inner = (expr) => highlight(expr);
+  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 (dartStringOpen(source, i)) {
+      const node = highlightDartString(source, i, inner);
+      for (const t of node.tokens) out.push(t);
+      i = node.end;
+      expectName = null;
+      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 === '@' || ch === '#') {
+      let j = i + 1;
+      while (j < n && /[A-Za-z0-9_$]/.test(source[j])) j += 1;
+      const kind = ch === '@' ? 'decorator' : 'constant';
+      emit(out, kind, 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, after, expectName };
+      emit(out, dartIdentStyle(ctx), word);
+      if (EXPECT_STYLE[expectName]) expectName = null;
+      else expectName = NEXT_EXPECT[word] ?? null;
+      i = end;
+      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;
+};
+
+module.exports = { langs, highlight };

package/lib/highlight/dot.js

@@ -0,0 +1,54 @@
+'use strict';
+
+const { emit } = require('./core.js');
+
+const langs = ['dot'];
+
+const aliases = {
+  env: 'dot',
+  ini: 'dot',
+  conf: 'dot',
+  cfg: 'dot',
+  yaml: 'dot',
+  yml: 'dot',
+  toml: 'dot',
+};
+
+const highlightDotLine = (line) => {
+  if (!line) return [];
+  const out = [];
+  const t = line.trimStart();
+  if (t.startsWith('#') || t.startsWith(';')) {
+    emit(out, 'comment', line);
+    return out;
+  }
+  if (t.startsWith('!')) {
+    const lead = line.slice(0, line.length - t.length);
+    emit(out, 'plain', lead);
+    emit(out, 'operator', '!');
+    emit(out, 'plain', t.slice(1));
+    return out;
+  }
+  const eq = line.match(/^(\s*)([A-Za-z_][A-Za-z0-9_.-]*)(\s*=\s*)(.*)$/);
+  if (eq) {
+    emit(out, 'plain', eq[1]);
+    emit(out, 'variable', eq[2]);
+    emit(out, 'operator', eq[3]);
+    emit(out, 'string', eq[4]);
+    return out;
+  }
+  emit(out, 'plain', line);
+  return out;
+};
+
+const highlight = (source) => {
+  const lines = source.split('\n');
+  const out = [];
+  for (let i = 0; i < lines.length; i += 1) {
+    if (i) emit(out, 'plain', '\n');
+    for (const t of highlightDotLine(lines[i])) out.push(t);
+  }
+  return out;
+};
+
+module.exports = { langs, aliases, highlight };