@kyyinfinite/lumina 1.0.0

package/src/media/fetch.js

@@ -0,0 +1,67 @@
+/**
+ * @file fetch.js
+ * @module lumina/media/fetch
+ *
+ * HTTP fetcher for media URLs. Returns a Buffer. Honours a configurable
+ * timeout and an opt-in `silent` mode (default OFF — fail loud).
+ */
+
+import { MediaError } from '../errors.js'
+
+/**
+ * @typedef {object} FetchOptions
+ * @property {boolean} [silent=false]  Swallow HTTP errors and return Buffer.alloc(0).
+ * @property {number}  [timeout=30000] Request timeout in milliseconds.
+ * @property {Record<string, string>} [headers] Additional request headers.
+ * @property {AbortSignal} [signal]    External abort signal.
+ */
+
+/**
+ * Fetch a URL and return its body as a Buffer.
+ *
+ * @param {string} url
+ * @param {FetchOptions} [opts]
+ * @returns {Promise<Buffer>}
+ * @throws {MediaError}  When `silent` is false (default) and the request fails.
+ */
+export async function fetchBuffer(url, opts = {}) {
+  const { silent = false, timeout = 30_000, headers, signal } = opts
+
+  try {
+    if (typeof url !== 'string' || !/^https?:\/\//i.test(url)) {
+      throw new MediaError(`invalid URL: ${url}`, { code: 'LUMINA_MEDIA_BAD_URL' })
+    }
+
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), timeout)
+    // Combine external signal with our timeout signal.
+    if (signal) {
+      if (signal.aborted) controller.abort()
+      else signal.addEventListener('abort', () => controller.abort(), { once: true })
+    }
+
+    const response = await fetch(url, {
+      headers,
+      signal: controller.signal,
+      redirect: 'follow',
+    })
+    clearTimeout(timer)
+
+    if (!response.ok) {
+      throw new MediaError(`HTTP ${response.status} for ${url}`, {
+        code: 'LUMINA_MEDIA_HTTP_ERROR',
+      })
+    }
+
+    return Buffer.from(await response.arrayBuffer())
+  } catch (err) {
+    if (silent) return Buffer.alloc(0)
+    if (err instanceof MediaError) throw err
+    throw new MediaError(`fetch failed for ${url}: ${err.message}`, {
+      code: 'LUMINA_MEDIA_FETCH_FAILED',
+      cause: err,
+    })
+  }
+}
+
+export default fetchBuffer

package/src/media/image.js

@@ -0,0 +1,86 @@
+/**
+ * @file image.js
+ * @module lumina/media/image
+ *
+ * Image resizing via `sharp`. Sharp is an optional peer dependency — the
+ * module lazy-imports it on first use so that users who never touch image
+ * resizing do not need it installed.
+ */
+
+import { MediaError } from '../errors.js'
+
+let sharpPromise = null
+
+/**
+ * Lazy-load sharp. Cached so the import cost is paid only once.
+ *
+ * @returns {Promise<typeof import('sharp')>}
+ */
+async function loadSharp() {
+  if (!sharpPromise) {
+    sharpPromise = (async () => {
+      try {
+        return await import('sharp')
+      } catch (err) {
+        throw new MediaError(
+          "sharp is not installed. Install it with `npm i sharp` to use image resizing.",
+          { code: 'LUMINA_MEDIA_SHARP_MISSING', cause: err },
+        )
+      }
+    })()
+  }
+  return sharpPromise
+}
+
+/**
+ * @typedef {object} ResizeOptions
+ * @property {number} [width]
+ * @property {number} [height]
+ * @property {'cover'|'contain'|'inside'|'outside'} [fit='cover']
+ * @property {'png'|'jpeg'|'webp'} [format='png']
+ * @property {object} [background]  Background colour for transparent areas.
+ */
+
+/**
+ * Resize a buffer containing an image. Returns a Buffer in the requested format.
+ *
+ * @param {Buffer} buffer
+ * @param {ResizeOptions} [opts]
+ * @returns {Promise<Buffer>}
+ */
+export async function resize(buffer, opts = {}) {
+  if (!Buffer.isBuffer(buffer) || buffer.length === 0) {
+    throw new MediaError('resize() requires a non-empty Buffer', {
+      code: 'LUMINA_MEDIA_EMPTY_BUFFER',
+    })
+  }
+
+  const { width = 300, height = 300, fit = 'cover', format = 'png', background } = opts
+  const sharp = await loadSharp()
+
+  let pipeline = sharp(buffer).resize(width, height, {
+    fit,
+    position: 'center',
+    background: background ?? { r: 0, g: 0, b: 0, alpha: 0 },
+  })
+
+  if (format === 'jpeg') pipeline = pipeline.jpeg()
+  else if (format === 'webp') pipeline = pipeline.webp()
+  else pipeline = pipeline.png()
+
+  return pipeline.toBuffer()
+}
+
+/**
+ * Convenience: resize to a square thumbnail (default 300×300 PNG cover).
+ *
+ * @param {Buffer} buffer
+ * @param {number} [size=300]
+ * @param {ResizeOptions['format']} [format]
+ * @returns {Promise<Buffer>}
+ */
+export async function thumbnail(buffer, size = 300, format = 'png') {
+  return resize(buffer, { width: size, height: size, fit: 'cover', format })
+}
+
+export default { resize, thumbnail }

package/src/media/index.d.ts

@@ -0,0 +1 @@
+export * from '../index.d.ts'

package/src/media/index.js

@@ -0,0 +1,12 @@
+/**
+ * @file media/index.js
+ * @module lumina/media
+ *
+ * Barrel re-export for the media layer.
+ */
+
+export { fetchBuffer } from './fetch.js'
+export { resize, thumbnail } from './image.js'
+export { getMp4Duration, extractThumbnail } from './video.js'
+export { uploadToWhatsApp, DEFAULT_UPLOAD_JID } from './uploader.js'
+export { resolveMedia } from './resolver.js'

package/src/media/resolver.js

@@ -0,0 +1,115 @@
+/**
+ * @file resolver.js
+ * @module lumina/media/resolver
+ *
+ * Unified media resolver. Accepts URL | base64 string | Buffer | array-of-any
+ * and returns a normalised representation per the requested strategy.
+ *
+ * Bug fix vs legacy: the original `Toolkit.resolveMedia` had two near-identical
+ * branches (WAUrl vs non-WAUrl) that both called `fetchBuffer` — collapsed
+ * into a single, explicit 3-strategy switch (`auto | url-only | buffer |
+ * base64 | upload`).
+ */
+
+import { MediaError } from '../errors.js'
+import { fetchBuffer } from './fetch.js'
+import { resize } from './image.js'
+import { uploadToWhatsApp } from './uploader.js'
+
+const HTTP_RE = /^https?:\/\/.+/i
+const WA_HOST_RE = /^https?:\/\/[^/]*\.whatsapp\.net\//i
+
+/** @typedef {'auto'|'url-only'|'buffer'|'base64'|'upload'} ResolveStrategy */
+
+/**
+ * @typedef {object} ResolveOptions
+ * @property {'image'|'video'|'audio'|'document'} [mediaType='image']
+ * @property {ResolveStrategy} [strategy='auto']
+ * @property {{ width: number, height: number, fit?: string }} [resize]   Resize before returning (buffer/base64 only).
+ * @property {boolean} [silent=false]
+ * @property {string} [jid]  Override upload JID.
+ */
+
+/**
+ * Resolve a single media source.
+ *
+ * @param {import('../client/connection.js').Connection} conn
+ * @param {string | Buffer} source
+ * @param {ResolveOptions} [opts]
+ * @returns {Promise<string | Buffer>}
+ */
+export async function resolveMedia(conn, source, opts = {}) {
+  const {
+    mediaType = 'image',
+    strategy = 'auto',
+    resize: resizeOpts,
+    silent = false,
+    jid,
+  } = opts
+
+  // Array support: recurse with identical opts.
+  if (Array.isArray(source)) {
+    return Promise.all(source.map((s) => resolveMedia(conn, s, opts)))
+  }
+
+  const originalIsBuffer = Buffer.isBuffer(source)
+
+  // Stage 1: normalise to either { url } or { buffer }.
+  let buffer = null
+  let url = null
+
+  if (typeof source === 'string') {
+    if (HTTP_RE.test(source)) {
+      const isWaUrl = WA_HOST_RE.test(source)
+      if (strategy === 'url-only' && isWaUrl) return source
+      // For HTTP URLs we always need the bytes — either because the user
+      // asked for buffer/base64, or because we need to upload to WhatsApp.
+      buffer = await fetchBuffer(source, { silent: true })
+      url = source
+    } else {
+      // Treat as base64.
+      buffer = Buffer.from(source, 'base64')
+    }
+  } else if (originalIsBuffer) {
+    buffer = source
+  } else {
+    throw new MediaError('source must be string URL, base64 string, or Buffer', {
+      code: 'LUMINA_MEDIA_BAD_SOURCE',
+    })
+  }
+
+  if (!buffer || buffer.length === 0) {
+    if (silent) return strategy === 'base64' ? '' : Buffer.alloc(0)
+    throw new MediaError(`could not fetch media for source: ${String(source).slice(0, 80)}`, {
+      code: 'LUMINA_MEDIA_EMPTY_AFTER_FETCH',
+    })
+  }
+
+  // Stage 2: optional resize.
+  if (resizeOpts && buffer) {
+    buffer = await resize(buffer, resizeOpts)
+  }
+
+  // Stage 3: format per strategy.
+  switch (strategy) {
+    case 'buffer':
+      return buffer
+    case 'base64':
+      return buffer.toString('base64')
+    case 'url-only':
+      if (url && WA_HOST_RE.test(url)) return url
+      throw new MediaError('url-only strategy requires a wa.me URL', {
+        code: 'LUMINA_MEDIA_URL_ONLY_FAILED',
+      })
+    case 'upload':
+      return uploadToWhatsApp(conn, buffer, mediaType, { jid })
+    case 'auto':
+    default:
+      if (url && WA_HOST_RE.test(url)) return url
+      if (originalIsBuffer) return uploadToWhatsApp(conn, buffer, mediaType, { jid })
+      // We have a non-WA URL — upload to WhatsApp so the consumer gets a CDN URL.
+      return uploadToWhatsApp(conn, buffer, mediaType, { jid })
+  }
+}
+
+export default resolveMedia

package/src/media/uploader.js

@@ -0,0 +1,65 @@
+/**
+ * @file uploader.js
+ * @module lumina/media/uploader
+ *
+ * Thin wrapper around Baileys' `prepareWAMessageMedia` that uploads a buffer
+ * (or `{ url }`) to WhatsApp and returns the resulting CDN URL.
+ *
+ * Bug fix vs legacy: the hardcoded `jid: '@newsletter'` (which silently
+ * forced every media upload through the newsletter queue) is replaced by a
+ * configurable default that the user can override via the `Connection`
+ * options or per-call `jid`.
+ */
+
+import { MediaError } from '../errors.js'
+
+/**
+ * Default pre-upload JID. Use a stable bot JID that WhatsApp accepts for
+ * media pre-uploads — historically the legacy code used `@newsletter`, but
+ * that route is rate-limited and intended for broadcast use. The default
+ * `s.whatsapp.net` route is more permissive and works for bot accounts.
+ */
+export const DEFAULT_UPLOAD_JID = '62831@s.whatsapp.net'
+
+/**
+ * Upload a media source to WhatsApp and return its CDN URL.
+ *
+ * @param {import('../client/connection.js').Connection} conn
+ * @param {Buffer | { url: string }} source
+ * @param {'image'|'video'|'audio'|'document'} mediaType
+ * @param {object} [opts]
+ * @param {string} [opts.jid=DEFAULT_UPLOAD_JID]   Pre-upload JID.
+ * @param {object} [opts.options]                   Extra options forwarded to `prepareWAMessageMedia`.
+ * @returns {Promise<string>}  CDN URL.
+ */
+export async function uploadToWhatsApp(conn, source, mediaType, opts = {}) {
+  if (!conn?.uploadMedia) {
+    throw new MediaError('connection.uploadMedia is not available', {
+      code: 'LUMINA_MEDIA_NO_UPLOAD_PORT',
+    })
+  }
+
+  const jid = opts.jid ?? DEFAULT_UPLOAD_JID
+  const media = {
+    [mediaType]: Buffer.isBuffer(source) ? source : { url: source.url ?? source },
+  }
+
+  try {
+    const result = await conn.uploadMedia(media, { jid, ...(opts.options ?? {}) })
+    const url = result?.[mediaType]?.url
+    if (!url) {
+      throw new MediaError(`upload succeeded but no URL returned for mediaType=${mediaType}`, {
+        code: 'LUMINA_MEDIA_UPLOAD_NO_URL',
+      })
+    }
+    return url
+  } catch (err) {
+    if (err instanceof MediaError) throw err
+    throw new MediaError(`upload failed: ${err.message}`, {
+      code: 'LUMINA_MEDIA_UPLOAD_FAILED',
+      cause: err,
+    })
+  }
+}
+
+export default { uploadToWhatsApp, DEFAULT_UPLOAD_JID }

package/src/media/video.js

@@ -0,0 +1,195 @@
+/**
+ * @file video.js
+ * @module lumina/media/video
+ *
+ * Pure-Node MP4 box parser (for duration) + ffmpeg-based thumbnail extractor.
+ *
+ * The legacy `Toolkit.getMp4Duration` was a hand-rolled ISO-BMFF box walker
+ * that worked but had no tests and several silent-failure paths. Lumina
+ * keeps the same approach (no native deps for duration) but factors it into
+ * a single, documented function.
+ *
+ * `extractThumbnail` lazy-imports `fluent-ffmpeg` — users who never send
+ * video thumbnails do not need it installed.
+ */
+
+import { PassThrough, Readable } from 'node:stream'
+
+import { MediaError } from '../errors.js'
+import { resize } from './image.js'
+
+let ffmpegPromise = null
+
+async function loadFfmpeg() {
+  if (!ffmpegPromise) {
+    ffmpegPromise = (async () => {
+      try {
+        return (await import('fluent-ffmpeg')).default
+      } catch (err) {
+        throw new MediaError(
+          "fluent-ffmpeg is not installed. Install it with `npm i fluent-ffmpeg` (and ffmpeg itself) to use video thumbnails.",
+          { code: 'LUMINA_MEDIA_FFMPEG_MISSING', cause: err },
+        )
+      }
+    })()
+  }
+  return ffmpegPromise
+}
+
+/**
+ * Walk the ISO-BMFF box tree of an MP4 buffer and extract the duration
+ * (in seconds) from the first `mvhd` box found inside `moov`.
+ *
+ * Returns 0 when the buffer is invalid, truncated, or lacks a `moov`/`mvhd`
+ * box — `silent: true` (default) preserves the legacy swallow-on-failure
+ * behaviour so that video uploads do not hard-fail when metadata is missing.
+ *
+ * @param {Buffer} buffer
+ * @param {object} [opts]
+ * @param {boolean} [opts.silent=true]
+ * @returns {number}  Duration in seconds (0 on failure).
+ */
+export function getMp4Duration(buffer, opts = {}) {
+  const { silent = true } = opts
+
+  const fail = (msg) => {
+    if (silent) return 0
+    throw new MediaError(msg, { code: 'LUMINA_MEDIA_MP4_PARSE_FAILED' })
+  }
+
+  try {
+    if (!Buffer.isBuffer(buffer) || buffer.length < 8) {
+      return fail('invalid buffer: too short')
+    }
+
+    let offset = 0
+    while (offset < buffer.length - 8) {
+      const size = buffer.readUInt32BE(offset)
+      if (size < 8 || offset + size > buffer.length) {
+        return fail('invalid atom size')
+      }
+
+      const type = buffer.toString('ascii', offset + 4, offset + 8)
+      if (type === 'moov') {
+        let moovOffset = offset + 8
+        const moovEnd = offset + size
+        while (moovOffset < moovEnd - 8) {
+          const childSize = buffer.readUInt32BE(moovOffset)
+          if (childSize < 8 || moovOffset + childSize > moovEnd) {
+            return fail('invalid child atom size')
+          }
+          const childType = buffer.toString('ascii', moovOffset + 4, moovOffset + 8)
+          if (childType === 'mvhd') {
+            const version = buffer.readUInt8(moovOffset + 8)
+            if (version === 0) {
+              const timescale = buffer.readUInt32BE(moovOffset + 20)
+              const duration = buffer.readUInt32BE(moovOffset + 24)
+              if (!timescale) return fail('invalid timescale')
+              return duration / timescale
+            }
+            if (version === 1) {
+              const timescale = buffer.readUInt32BE(moovOffset + 32)
+              const duration = Number(buffer.readBigUInt64BE(moovOffset + 36))
+              if (!timescale) return fail('invalid timescale')
+              return duration / timescale
+            }
+          }
+          moovOffset += childSize
+        }
+      }
+      offset += size
+    }
+    return fail('no mvhd found')
+  } catch (err) {
+    if (silent) return 0
+    throw new MediaError(`mp4 duration parse error: ${err.message}`, {
+      code: 'LUMINA_MEDIA_MP4_PARSE_FAILED',
+      cause: err,
+    })
+  }
+}
+
+/**
+ * @typedef {object} ThumbnailOptions
+ * @property {number|string} [time='auto']   Seek position (seconds) or 'auto' (= 20% of duration, capped at 10s).
+ * @property {number} [width=300]
+ * @property {number} [height=300]
+ * @property {'png'|'jpeg'|'webp'} [format='png']
+ * @property {boolean} [resizeOutput=true]   Pass the frame through `sharp.resize()`.
+ * @property {boolean} [silent=true]         Swallow ffmpeg errors and return empty Buffer.
+ * @property {'buffer'|'base64'} [result='buffer']
+ */
+
+/**
+ * Extract a single frame from an MP4 buffer at the given timestamp.
+ *
+ * @param {Buffer} videoBuffer
+ * @param {ThumbnailOptions} [opts]
+ * @returns {Promise<Buffer|string>}  Buffer or base64 string (per `result`).
+ */
+export async function extractThumbnail(videoBuffer, opts = {}) {
+  const {
+    time,
+    width = 300,
+    height = 300,
+    format = 'png',
+    resizeOutput = true,
+    silent = true,
+    result = 'buffer',
+  } = opts
+
+  const ffmpeg = await loadFfmpeg()
+
+  return new Promise((resolve, reject) => {
+    const fail = (err) => {
+      if (silent) return resolve(result === 'base64' ? '' : Buffer.alloc(0))
+      reject(err instanceof MediaError ? err : new MediaError(err?.message ?? String(err), {
+        code: 'LUMINA_MEDIA_FFMPEG_FAILED',
+        cause: err,
+      }))
+    }
+
+    if (!Buffer.isBuffer(videoBuffer) || videoBuffer.length === 0) {
+      return fail(new MediaError('videoBuffer is empty', { code: 'LUMINA_MEDIA_EMPTY_BUFFER' }))
+    }
+
+    const seekTime = time ?? Math.min(getMp4Duration(videoBuffer) * 0.2, 10)
+
+    const input = new Readable({ read() {} })
+    input.push(videoBuffer)
+    input.push(null)
+
+    const output = new PassThrough()
+    const chunks = []
+    output.on('data', (c) => chunks.push(c))
+    output.on('end', async () => {
+      try {
+        let frame = Buffer.concat(chunks)
+        if (frame.length === 0) {
+          return fail(new MediaError('ffmpeg produced empty output', { code: 'LUMINA_MEDIA_FFMPEG_EMPTY' }))
+        }
+        if (resizeOutput) {
+          frame = await resize(frame, { width, height, fit: 'cover', format })
+        }
+        resolve(result === 'base64' ? frame.toString('base64') : frame)
+      } catch (err) {
+        fail(err)
+      }
+    })
+    output.on('error', fail)
+
+    try {
+      ffmpeg(input)
+        .outputOptions([`-ss ${seekTime}`, '-vframes 1', '-vcodec png', '-f image2pipe'])
+        .on('error', (err) => fail(new MediaError(`ffmpeg error: ${err.message}`, {
+          code: 'LUMINA_MEDIA_FFMPEG_FAILED',
+          cause: err,
+        })))
+        .pipe(output, { end: true })
+    } catch (err) {
+      fail(err)
+    }
+  })
+}
+
+export default { getMp4Duration, extractThumbnail }

package/src/parsers/code-tokenizer-keywords.js

@@ -0,0 +1,128 @@
+/**
+ * @file code-tokenizer-keywords.js
+ * @module lumina/parsers/code-tokenizer-keywords
+ *
+ * Language keyword catalog. Built ONCE at module-load time (vs the legacy
+ * `AIRich.tokenizer` which rebuilt a `new Set(...)` on every call).
+ *
+ * Twelve languages are supported out of the box. To add a new language,
+ * append a `Set` here — the lexer picks it up automatically.
+ */
+
+/** @type {Record<string, Set<string>>} */
+export const KEYWORDS = {
+  javascript: new Set([
+    'break', 'case', 'catch', 'continue', 'debugger', 'default', 'delete', 'do', 'else',
+    'export', 'extends', 'finally', 'for', 'function', 'if', 'import', 'in', 'instanceof',
+    'new', 'return', 'super', 'switch', 'this', 'throw', 'try', 'typeof', 'var', 'void',
+    'while', 'with', 'yield', 'class', 'const', 'let', 'static', 'async', 'await', 'get', 'set',
+    'true', 'false', 'null', 'undefined',
+  ]),
+
+  typescript: new Set([
+    'abstract', 'any', 'as', 'asserts', 'bigint', 'boolean', 'break', 'case', 'catch', 'class',
+    'const', 'continue', 'debugger', 'declare', 'default', 'delete', 'do', 'else', 'enum',
+    'export', 'extends', 'finally', 'for', 'from', 'function', 'if', 'implements', 'import',
+    'in', 'infer', 'instanceof', 'interface', 'is', 'keyof', 'let', 'module', 'namespace',
+    'new', 'never', 'null', 'number', 'object', 'of', 'override', 'package', 'private',
+    'protected', 'public', 'readonly', 'require', 'return', 'satisfies', 'string', 'super',
+    'switch', 'symbol', 'this', 'throw', 'true', 'false', 'try', 'type', 'typeof', 'undefined',
+    'unknown', 'using', 'var', 'void', 'while', 'with', 'yield', 'async', 'await', 'static', 'as',
+  ]),
+
+  python: new Set([
+    'False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class',
+    'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global',
+    'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return',
+    'try', 'while', 'with', 'yield',
+  ]),
+
+  java: new Set([
+    'abstract', 'assert', 'boolean', 'break', 'byte', 'case', 'catch', 'char', 'class', 'const',
+    'continue', 'default', 'do', 'double', 'else', 'enum', 'extends', 'final', 'finally',
+    'float', 'for', 'goto', 'if', 'implements', 'import', 'instanceof', 'int', 'interface',
+    'long', 'native', 'new', 'package', 'private', 'protected', 'public', 'return', 'short',
+    'static', 'strictfp', 'super', 'switch', 'synchronized', 'this', 'throw', 'throws',
+    'transient', 'try', 'void', 'volatile', 'while', 'true', 'false', 'null',
+  ]),
+
+  golang: new Set([
+    'break', 'case', 'chan', 'const', 'continue', 'default', 'defer', 'else', 'fallthrough',
+    'for', 'func', 'go', 'goto', 'if', 'import', 'interface', 'map', 'package', 'range',
+    'return', 'select', 'struct', 'switch', 'type', 'var', 'true', 'false', 'nil', 'iota',
+  ]),
+
+  c: new Set([
+    'auto', 'break', 'case', 'char', 'const', 'continue', 'default', 'do', 'double', 'else',
+    'enum', 'extern', 'float', 'for', 'goto', 'if', 'inline', 'int', 'long', 'register',
+    'restrict', 'return', 'short', 'signed', 'sizeof', 'static', 'struct', 'switch', 'typedef',
+    'union', 'unsigned', 'void', 'volatile', 'while', '_Bool', '_Complex', '_Imaginary',
+  ]),
+
+  cpp: new Set([
+    'alignas', 'alignof', 'and', 'auto', 'bool', 'break', 'case', 'catch', 'char', 'class',
+    'const', 'constexpr', 'continue', 'decltype', 'default', 'delete', 'do', 'double', 'else',
+    'enum', 'explicit', 'export', 'extern', 'false', 'float', 'for', 'friend', 'goto', 'if',
+    'inline', 'int', 'long', 'mutable', 'namespace', 'new', 'noexcept', 'nullptr', 'operator',
+    'private', 'protected', 'public', 'register', 'return', 'short', 'signed', 'sizeof',
+    'static', 'static_cast', 'struct', 'switch', 'template', 'this', 'throw', 'true', 'try',
+    'typedef', 'typename', 'union', 'unsigned', 'using', 'virtual', 'void', 'volatile', 'while',
+  ]),
+
+  php: new Set([
+    'abstract', 'and', 'array', 'as', 'break', 'callable', 'case', 'catch', 'class', 'clone',
+    'const', 'continue', 'declare', 'default', 'do', 'echo', 'else', 'elseif', 'empty',
+    'enddeclare', 'endfor', 'endforeach', 'endif', 'endswitch', 'endwhile', 'extends', 'final',
+    'finally', 'fn', 'for', 'foreach', 'function', 'global', 'goto', 'if', 'implements',
+    'include', 'include_once', 'instanceof', 'interface', 'match', 'namespace', 'new', 'null',
+    'or', 'private', 'protected', 'public', 'readonly', 'require', 'require_once', 'return',
+    'static', 'switch', 'throw', 'trait', 'try', 'use', 'var', 'while', 'yield', 'true',
+    'false', 'fn',
+  ]),
+
+  rust: new Set([
+    'as', 'async', 'await', 'break', 'const', 'continue', 'crate', 'dyn', 'else', 'enum',
+    'extern', 'false', 'fn', 'for', 'if', 'impl', 'in', 'let', 'loop', 'match', 'mod', 'move',
+    'mut', 'pub', 'ref', 'return', 'self', 'Self', 'static', 'struct', 'super', 'trait',
+    'true', 'type', 'unsafe', 'use', 'where', 'while', 'yield',
+  ]),
+
+  html: new Set([
+    'html', 'head', 'body', 'div', 'span', 'p', 'a', 'img', 'video', 'audio', 'script',
+    'style', 'link', 'meta', 'form', 'input', 'button', 'table', 'tr', 'td', 'th', 'ul', 'ol',
+    'li', 'section', 'article', 'header', 'footer', 'nav', 'main',
+  ]),
+
+  css: new Set([
+    'color', 'background', 'background-color', 'background-image', 'background-size', 'border',
+    'border-radius', 'margin', 'padding', 'width', 'height', 'display', 'position', 'top',
+    'right', 'bottom', 'left', 'flex', 'flex-direction', 'justify-content', 'align-items',
+    'grid', 'grid-template-columns', 'font', 'font-size', 'font-weight', 'text-align',
+    'text-decoration', 'opacity', 'transition', 'transform', 'animation', 'z-index', 'overflow',
+    'cursor', 'box-shadow', 'content', 'media', 'keyframes', 'important',
+  ]),
+
+  bash: new Set([
+    'if', 'then', 'else', 'elif', 'fi', 'for', 'while', 'do', 'done', 'case', 'esac',
+    'function', 'in', 'select', 'until', 'break', 'continue', 'return', 'exit', 'export',
+    'readonly', 'local', 'declare', 'unset', 'shift', 'eval', 'exec', 'trap', 'set', 'source',
+    'alias', 'echo', 'printf', 'read', 'cd', 'pwd', 'pushd', 'popd',
+  ]),
+
+  markdown: new Set(['#', '##', '###', '####', '#####', '######']),
+}
+
+/** Languages where `//` introduces a line comment. */
+export const SLASH_COMMENT_LANGS = new Set([
+  'javascript', 'typescript', 'java', 'golang', 'c', 'cpp', 'php', 'rust', 'css',
+])
+
+/** Languages where `#` introduces a line comment. */
+export const HASH_COMMENT_LANGS = new Set(['python', 'bash', 'php', 'rust'])
+
+/** Languages that support block comments with `/* ... *\/`. */
+export const BLOCK_COMMENT_LANGS = new Set([
+  'javascript', 'typescript', 'java', 'c', 'cpp', 'php', 'css',
+])
+
+export default KEYWORDS