@kyyinfinite/lumina 1.0.0 → 1.0.1

package/src/index.js

@@ -1,151 +1,50 @@
-/**
- * @file index.js
- * @module @kyyinfinite/lumina
- *
- * Lumina — Modern WhatsApp framework built on top of Baileys.
- *
- * Public API surface:
- *
- *   import { Bot } from '@kyyinfinite/lumina'
- *   const bot = new Bot(socket)
- *   await bot.text(jid, 'Halo')
- *
- * Subpath exports (tree-shakable):
- *
- *   import { extractInlineEntities } from '@kyyinfinite/lumina/parsers'
- *   import { MediaService }          from '@kyyinfinite/lumina/services'
- *   import { ButtonBuilder }         from '@kyyinfinite/lumina/builders'
- *   import { ProtoUpdater }          from '@kyyinfinite/lumina/proto'
- *   import { resize }                from '@kyyinfinite/lumina/media'
- */
-
 import { Bot } from './client/bot.js'
 import { Connection } from './client/connection.js'
-
 import { ButtonBuilder } from './builders/button.js'
 import { ButtonV2Builder } from './builders/button-v2.js'
 import { CarouselBuilder } from './builders/carousel.js'
 import { CardBuilder } from './builders/card.js'
 import { AIRichBuilder } from './builders/ai-rich.js'
-
 import { MediaService } from './services/media-service.js'
 import { ProtoService } from './services/proto-service.js'
 import { MessageService } from './services/message-service.js'
-
 import { extractInlineEntities } from './parsers/inline-entity.js'
 import { tokenizeCode } from './parsers/code-tokenizer.js'
 import { toTableMetadata } from './parsers/table-metadata.js'
-
 import { ProtoUpdater, transformToESM, applyKnownFixes } from './proto/updater.js'
 import { assembleRichResponse } from './proto/rich-response.js'
 import { createInteractiveNodes, createBareInteractiveNodes } from './proto/relay-nodes.js'
-
-// Catalog re-exports — these are imported so that the named exports below
-// are available from the root `@kyyinfinite/lumina` entry point.
 import {
-  MessageType,
-  ForwardOrigin,
-  HeaderType,
-  NativeFlow,
-  BOT_JID,
-  LayoutKind,
-  HighlightType,
-  HighlightLabel,
-  ImagineType,
-  SourceType,
-  PromptType,
-  SessionTransparencyType,
-  TYPENAME,
+  MessageType, ForwardOrigin, HeaderType, NativeFlow, BOT_JID, LayoutKind,
+  HighlightType, HighlightLabel, ImagineType, SourceType, PromptType,
+  SessionTransparencyType, TYPENAME, SimpleButtonType,
 } from './proto/enums.js'
-
 import {
-  markdownTextPrimitive,
-  codePrimitive,
-  tablePrimitive,
-  searchResultPrimitive,
-  reelPrimitive,
-  imaginePrimitive,
-  productCardPrimitive,
-  postPrimitive,
-  metadataTextPrimitive,
-  followUpSuggestionPillPrimitive,
-  shapeSourceEntry,
-  shapeReelEntry,
+  markdownTextPrimitive, codePrimitive, tablePrimitive, searchResultPrimitive,
+  reelPrimitive, imaginePrimitive, productCardPrimitive, postPrimitive,
+  metadataTextPrimitive, followUpSuggestionPillPrimitive, shapeSourceEntry, shapeReelEntry,
 } from './proto/primitives.js'
-
 import { singleLayout, hscrollLayout, actionRowLayout, layoutFor } from './proto/layouts.js'
-
 import { LuminaError, ValidationError, MediaError, ProtoError, ConnectionError, ProtocolError } from './errors.js'
 import { createLogger } from './utils/logger.js'
 
-/** Semver version of the Lumina package. */
 export const VERSION = '1.0.0'
 
-// Public API
 export {
-  Bot,
-  Connection,
-  // Builders
-  ButtonBuilder,
-  ButtonV2Builder,
-  CarouselBuilder,
-  CardBuilder,
-  AIRichBuilder,
-  // Services
-  MediaService,
-  ProtoService,
-  MessageService,
-  // Parsers
-  extractInlineEntities,
-  tokenizeCode,
-  toTableMetadata,
-  // Proto
-  ProtoUpdater,
-  transformToESM,
-  applyKnownFixes,
-  assembleRichResponse,
-  createInteractiveNodes,
-  createBareInteractiveNodes,
-  // Catalog
-  MessageType,
-  ForwardOrigin,
-  HeaderType,
-  NativeFlow,
-  BOT_JID,
-  LayoutKind,
-  HighlightType,
-  HighlightLabel,
-  ImagineType,
-  SourceType,
-  PromptType,
-  SessionTransparencyType,
-  TYPENAME,
-  // Primitive factories
-  markdownTextPrimitive,
-  codePrimitive,
-  tablePrimitive,
-  searchResultPrimitive,
-  reelPrimitive,
-  imaginePrimitive,
-  productCardPrimitive,
-  postPrimitive,
-  metadataTextPrimitive,
-  followUpSuggestionPillPrimitive,
-  shapeSourceEntry,
-  shapeReelEntry,
-  // Layout factories
-  singleLayout,
-  hscrollLayout,
-  actionRowLayout,
-  layoutFor,
-  // Errors
-  LuminaError,
-  ValidationError,
-  MediaError,
-  ProtoError,
-  ConnectionError,
-  ProtocolError,
-  // Utils
+  Bot, Connection,
+  ButtonBuilder, ButtonV2Builder, CarouselBuilder, CardBuilder, AIRichBuilder,
+  MediaService, ProtoService, MessageService,
+  extractInlineEntities, tokenizeCode, toTableMetadata,
+  ProtoUpdater, transformToESM, applyKnownFixes,
+  assembleRichResponse, createInteractiveNodes, createBareInteractiveNodes,
+  MessageType, ForwardOrigin, HeaderType, NativeFlow, BOT_JID, LayoutKind,
+  HighlightType, HighlightLabel, ImagineType, SourceType, PromptType,
+  SessionTransparencyType, TYPENAME, SimpleButtonType,
+  markdownTextPrimitive, codePrimitive, tablePrimitive, searchResultPrimitive,
+  reelPrimitive, imaginePrimitive, productCardPrimitive, postPrimitive,
+  metadataTextPrimitive, followUpSuggestionPillPrimitive, shapeSourceEntry, shapeReelEntry,
+  singleLayout, hscrollLayout, actionRowLayout, layoutFor,
+  LuminaError, ValidationError, MediaError, ProtoError, ConnectionError, ProtocolError,
   createLogger,
 }
 

package/src/media/fetch.js

@@ -1,29 +1,5 @@
-/**
- * @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
 
@@ -34,23 +10,16 @@ export async function fetchBuffer(url, opts = {}) {
 
     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',
-    })
+    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',
-      })
+      throw new MediaError(`HTTP ${response.status} for ${url}`, { code: 'LUMINA_MEDIA_HTTP_ERROR' })
     }
 
     return Buffer.from(await response.arrayBuffer())

package/src/media/image.js

@@ -1,21 +1,7 @@
-/**
- * @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 () => {
@@ -32,27 +18,9 @@ async function loadSharp() {
   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',
-    })
+    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
@@ -71,14 +39,6 @@ export async function resize(buffer, opts = {}) {
   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 })
 }

package/src/media/resolver.js

@@ -1,16 +1,3 @@
-/**
- * @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'
@@ -19,42 +6,14 @@ 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
+  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
 
@@ -62,12 +21,9 @@ export async function resolveMedia(conn, source, opts = {}) {
     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) {
@@ -85,12 +41,8 @@ export async function resolveMedia(conn, source, opts = {}) {
     })
   }
 
-  // Stage 2: optional resize.
-  if (resizeOpts && buffer) {
-    buffer = await resize(buffer, resizeOpts)
-  }
+  if (resizeOpts && buffer) buffer = await resize(buffer, resizeOpts)
 
-  // Stage 3: format per strategy.
   switch (strategy) {
     case 'buffer':
       return buffer
@@ -98,16 +50,12 @@ export async function resolveMedia(conn, source, opts = {}) {
       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',
-      })
+      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 })
   }
 }

package/src/media/uploader.js

@@ -1,37 +1,7 @@
-/**
- * @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', {

package/src/media/video.js

@@ -1,17 +1,6 @@
-/**
- * @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'
 
@@ -36,19 +25,8 @@ async function loadFfmpeg() {
   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
 
@@ -109,24 +87,8 @@ export function getMp4Duration(buffer, opts = {}) {
   }
 }
 
-/**
- * @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,

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

@@ -1,15 +1,6 @@
-/**
- * @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',
@@ -112,15 +103,12 @@ export const KEYWORDS = {
   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',
 ])

package/src/parsers/code-tokenizer.js

@@ -1,31 +1,11 @@
-/**
- * @file code-tokenizer.js
- * @module lumina/parsers/code-tokenizer
  *
- * Lightweight hand-rolled lexer for code-block syntax highlighting inside
- * AI Rich Responses. Returns two parallel representations:
  *
- *   - `codeBlock`       — array of `{ codeContent, highlightType }` where
- *                         `highlightType` is the numeric 0-5 enum used by WAProto.
- *   - `unifiedBlocks`   — array of `{ content, type }` with the string label
- *                         (`'DEFAULT' | 'KEYWORD' | 'METHOD' | 'STR' | 'NUMBER' | 'COMMENT'`).
  *
- * The legacy `AIRich.tokenizer` rebuilt its keyword Set on every call and
- * inlined all 660 lines of language maps. Lumina splits the catalog into
- * `code-tokenizer-keywords.js` (built once) and keeps this file focused on
- * the lexer itself (~120 lines).
- */
 
 import { HighlightType, HighlightLabel } from '../proto/enums.js'
 import { KEYWORDS, SLASH_COMMENT_LANGS, HASH_COMMENT_LANGS, BLOCK_COMMENT_LANGS } from './code-tokenizer-keywords.js'
 
-/**
- * @typedef {object} TokenizedCode
- * @property {Array<{ codeContent: string, highlightType: number }>} codeBlock
- * @property {Array<{ content: string, type: string }>} unifiedBlocks
- */
 
-/** Identifier character class per language (CSS & HTML allow `-` / `:`). */
 function identifierChar(lang) {
   switch (lang) {
     case 'css':
@@ -37,19 +17,12 @@ function identifierChar(lang) {
   }
 }
 
-/**
- * Tokenize a code string for syntax highlighting.
  *
- * @param {string} code
- * @param {string} [lang='javascript']   Lower-case language id. Unknown ids degrade gracefully to plain text.
- * @returns {TokenizedCode}
- */
 export function tokenizeCode(code, lang = 'javascript') {
   if (typeof code !== 'string' || code.length === 0) {
     return { codeBlock: [], unifiedBlocks: [] }
   }
 
-  // Plain-text fast-path.
   if (!lang || lang === 'txt' || lang === 'text' || lang === 'plaintext') {
     return {
       codeBlock: [{ codeContent: code, highlightType: HighlightType.DEFAULT }],
@@ -64,12 +37,8 @@ export function tokenizeCode(code, lang = 'javascript') {
   const supportsHashComments = HASH_COMMENT_LANGS.has(lower)
   const supportsBlockComments = BLOCK_COMMENT_LANGS.has(lower)
 
-  /** @type {Array<{ codeContent: string, highlightType: number }>} */
   const tokens = []
 
-  /**
-   * Push a token, merging with the previous one if both share the same type.
-   */
   const push = (content, type) => {
     if (!content) return
     const last = tokens[tokens.length - 1]
@@ -81,7 +50,6 @@ export function tokenizeCode(code, lang = 'javascript') {
   while (i < code.length) {
     const c = code[i]
 
-    // Whitespace.
     if (/\s/.test(c)) {
       const start = i
       while (i < code.length && /\s/.test(code[i])) i++
@@ -89,7 +57,6 @@ export function tokenizeCode(code, lang = 'javascript') {
       continue
     }
 
-    // Block comment: /* ... */
     if (supportsBlockComments && c === '/' && code[i + 1] === '*') {
       const start = i
       i += 2
@@ -99,7 +66,6 @@ export function tokenizeCode(code, lang = 'javascript') {
       continue
     }
 
-    // Slash line comment: //
     if (supportsSlashComments && c === '/' && code[i + 1] === '/') {
       const start = i
       while (i < code.length && code[i] !== '\n') i++
@@ -107,7 +73,6 @@ export function tokenizeCode(code, lang = 'javascript') {
       continue
     }
 
-    // Hash line comment: #  (python, bash, php, rust)
     if (supportsHashComments && c === '#') {
       const start = i
       while (i < code.length && code[i] !== '\n') i++
@@ -115,7 +80,6 @@ export function tokenizeCode(code, lang = 'javascript') {
       continue
     }
 
-    // String literals: ', ", `
     if (c === '"' || c === "'" || c === '`') {
       const start = i
       const quote = c
@@ -131,7 +95,6 @@ export function tokenizeCode(code, lang = 'javascript') {
       continue
     }
 
-    // Numbers.
     if (/[0-9]/.test(c)) {
       const start = i
       while (i < code.length && /[0-9._a-fxA-fX]/.test(code[i])) i++
@@ -139,7 +102,6 @@ export function tokenizeCode(code, lang = 'javascript') {
       continue
     }
 
-    // Identifiers & keywords.
     if (/[a-zA-Z_$]/.test(c)) {
       const start = i
       while (i < code.length && isIdent.test(code[i])) i++
@@ -150,12 +112,10 @@ export function tokenizeCode(code, lang = 'javascript') {
       if (keywords.has(word)) {
         type = HighlightType.KEYWORD
       } else if (lower === 'css') {
-        // Property name? next non-space char is ':'.
         let j = i
         while (j < code.length && /\s/.test(code[j])) j++
         if (code[j] === ':') type = HighlightType.KEYWORD
       } else if (lower === 'html') {
-        // Tag name? previous non-space char is '<' or '</'.
         let p = start - 1
         while (p >= 0 && /\s/.test(code[p])) p--
         if (code[p] === '<' || (code[p] === '/' && code[p - 1] === '<')) {
@@ -163,7 +123,6 @@ export function tokenizeCode(code, lang = 'javascript') {
         }
       }
 
-      // Function call? Next non-space char is '('.
       if (type === HighlightType.DEFAULT) {
         let j = i
         while (j < code.length && /\s/.test(code[j])) j++
@@ -174,7 +133,6 @@ export function tokenizeCode(code, lang = 'javascript') {
       continue
     }
 
-    // Everything else: punctuation.
     push(c, HighlightType.DEFAULT)
     i++
   }

package/src/parsers/index.js

@@ -1,10 +1,3 @@
-/**
- * @file parsers/index.js
- * @module lumina/parsers
- *
- * Barrel re-export for the parsers layer.
- */
-
 export { extractInlineEntities } from './inline-entity.js'
 export { tokenizeCode } from './code-tokenizer.js'
 export { toTableMetadata } from './table-metadata.js'