sugar-high 1.3.0 → 2.0.1

package/lib/lang.d.ts

@@ -0,0 +1,14 @@
+import type { LanguageName } from './index.js'
+import type { ParseOptions } from './core.js'
+
+export type Language = Readonly<{
+  id: LanguageName
+  /** Preferred file extension without a leading dot. */
+  extension: string
+  aliases: readonly string[]
+  config?: ParseOptions
+}>
+
+export const languages: readonly Language[]
+/** Normalize a language name, fence alias, or extension to its canonical name. */
+export function lang(name: string): LanguageName | undefined

package/lib/lang.js

@@ -0,0 +1,132 @@
+// @ts-check
+
+import * as c from './presets/lang/c.js'
+import * as cpp from './presets/lang/cpp.js'
+import * as csharp from './presets/lang/csharp.js'
+import * as css from './presets/lang/css.js'
+import * as diff from './presets/lang/diff.js'
+import * as dockerfile from './presets/lang/dockerfile.js'
+import * as go from './presets/lang/go.js'
+import * as html from './presets/lang/html.js'
+import * as graphql from './presets/lang/graphql.js'
+import * as hcl from './presets/lang/hcl.js'
+import * as java from './presets/lang/java.js'
+import * as json from './presets/lang/json.js'
+import * as javascript from './presets/lang/javascript.js'
+import * as kotlin from './presets/lang/kotlin.js'
+import * as markdown from './presets/lang/markdown.js'
+import * as php from './presets/lang/php.js'
+import * as powershell from './presets/lang/powershell.js'
+import * as python from './presets/lang/python.js'
+import * as rust from './presets/lang/rust.js'
+import * as shell from './presets/lang/shell.js'
+import * as sql from './presets/lang/sql.js'
+import * as swift from './presets/lang/swift.js'
+import * as toml from './presets/lang/toml.js'
+import * as typescript from './presets/lang/typescript.js'
+import * as yaml from './presets/lang/yaml.js'
+
+/**
+ * @typedef {import('./core.js').ParseOptions} ParseOptions
+ * @typedef {{
+ *   id: string
+ *   extension: string
+ *   aliases: readonly string[]
+ *   config?: ParseOptions
+ * }} Language
+ */
+
+/**
+ * Disable JavaScript-only scanner modes for a non-JavaScript language.
+ * @param {ParseOptions} config
+ * @returns {ParseOptions}
+ */
+function nonJavaScript(config) {
+  return {
+    ...config,
+    jsx: false,
+    regex: false,
+    templateStrings: false,
+  }
+}
+
+/** @type {readonly Language[]} */
+const languages = [
+  { id: 'javascript', extension: 'js', aliases: ['js', 'jsx', 'node'], config: javascript },
+  { id: 'typescript', extension: 'ts', aliases: ['ts', 'tsx'], config: typescript },
+  { id: 'css', extension: 'css', aliases: ['scss'], config: nonJavaScript(css) },
+  { id: 'python', extension: 'py', aliases: ['py', 'python3'], config: nonJavaScript(python) },
+  { id: 'c', extension: 'c', aliases: [], config: nonJavaScript(c) },
+  { id: 'go', extension: 'go', aliases: ['golang'], config: nonJavaScript(go) },
+  { id: 'java', extension: 'java', aliases: [], config: nonJavaScript(java) },
+  { id: 'rust', extension: 'rs', aliases: ['rs'], config: nonJavaScript(rust) },
+  { id: 'json', extension: 'json', aliases: ['jsonc'], config: nonJavaScript(json) },
+  { id: 'diff', extension: 'diff', aliases: ['patch'], config: nonJavaScript(diff) },
+  { id: 'shell', extension: 'sh', aliases: ['sh', 'bash', 'zsh'], config: nonJavaScript(shell) },
+  { id: 'cpp', extension: 'cpp', aliases: ['c++', 'cc', 'cxx'], config: nonJavaScript(cpp) },
+  { id: 'csharp', extension: 'cs', aliases: ['c#', 'cs', 'dotnet'], config: nonJavaScript(csharp) },
+  { id: 'sql', extension: 'sql', aliases: [], config: nonJavaScript(sql) },
+  { id: 'html', extension: 'html', aliases: ['htm', 'xml'], config: html },
+  { id: 'yaml', extension: 'yaml', aliases: ['yml'], config: nonJavaScript(yaml) },
+  { id: 'markdown', extension: 'md', aliases: ['md', 'mdx'], config: nonJavaScript(markdown) },
+  { id: 'kotlin', extension: 'kt', aliases: ['kts'], config: nonJavaScript(kotlin) },
+  { id: 'swift', extension: 'swift', aliases: [], config: nonJavaScript(swift) },
+  { id: 'php', extension: 'php', aliases: [], config: nonJavaScript(php) },
+  { id: 'toml', extension: 'toml', aliases: [], config: nonJavaScript(toml) },
+  { id: 'powershell', extension: 'ps1', aliases: ['pwsh'], config: nonJavaScript(powershell) },
+  { id: 'dockerfile', extension: 'dockerfile', aliases: ['docker'], config: nonJavaScript(dockerfile) },
+  { id: 'graphql', extension: 'graphql', aliases: ['gql'], config: nonJavaScript(graphql) },
+  { id: 'hcl', extension: 'hcl', aliases: ['terraform', 'tf'], config: nonJavaScript(hcl) },
+]
+
+/** @param {string} value */
+function normalizeLanguageName(value) {
+  return value.trim().toLowerCase().replace(/^\./, '')
+}
+
+/** @type {Map<string, Language>} */
+const languageLookup = new Map()
+
+for (const language of languages) {
+  const names = new Set([language.id, language.extension, ...language.aliases])
+  for (const name of names) {
+    const normalized = normalizeLanguageName(name)
+    const existing = languageLookup.get(normalized)
+    if (existing && existing !== language) {
+      throw new Error(
+        `Language name "${normalized}" is shared by "${existing.id}" and "${language.id}"`
+      )
+    }
+    languageLookup.set(normalized, language)
+  }
+}
+
+/**
+ * Find canonical language metadata using a name, alias, or preferred extension.
+ * @param {string} name
+ * @returns {Language | undefined}
+ */
+function findLanguage(name) {
+  if (typeof name !== 'string') return undefined
+  return languageLookup.get(normalizeLanguageName(name))
+}
+
+/**
+ * Find metadata only when the input is already a canonical language name.
+ * Direct highlighting uses this stricter lookup; integrations resolve aliases first.
+ * @param {string} name
+ * @returns {Language | undefined}
+ */
+/**
+ * Resolve a name, alias, or extension to its canonical language name.
+ * @param {string} name
+ * @returns {string | undefined}
+ */
+function lang(name) {
+  return findLanguage(name)?.id
+}
+
+export {
+  lang,
+  languages,
+}

package/lib/presets/lang/cpp.js

@@ -0,0 +1,22 @@
+// @ts-check
+import { onCommentEnd, onCommentStart } from './clike-base.js'
+
+export const keywords = new Set([
+  'alignas', 'alignof', 'and', 'and_eq', 'asm', 'auto', 'bitand', 'bitor', 'break',
+  'case', 'catch', 'class', 'compl', 'concept', 'const', 'consteval', 'constexpr',
+  'constinit', 'const_cast', 'continue', 'co_await', 'co_return', 'co_yield', 'decltype',
+  'default', 'delete', 'do', 'dynamic_cast', 'else', 'enum', 'explicit', 'export',
+  'extern', 'false', 'for', 'friend', 'goto', 'if', 'inline', 'mutable', 'namespace',
+  'new', 'noexcept', 'not', 'not_eq', 'nullptr', 'operator', 'or', 'or_eq', 'private',
+  'protected', 'public', 'register', 'reinterpret_cast', 'requires', 'return', 'sizeof',
+  'static', 'static_assert', 'static_cast', 'struct', 'switch', 'template', 'this',
+  'thread_local', 'throw', 'true', 'try', 'typedef', 'typeid', 'typename', 'union',
+  'using', 'virtual', 'volatile', 'while', 'xor', 'xor_eq',
+])
+
+export const typeKeywords = new Set([
+  'bool', 'char', 'char8_t', 'char16_t', 'char32_t', 'double', 'float', 'int', 'long',
+  'short', 'signed', 'unsigned', 'void', 'wchar_t',
+])
+
+export { onCommentEnd, onCommentStart }

package/lib/presets/lang/csharp.js

@@ -0,0 +1,21 @@
+// @ts-check
+import { onCommentEnd, onCommentStart } from './clike-base.js'
+
+export const keywords = new Set([
+  'abstract', 'as', 'async', 'await', 'base', 'break', 'case', 'catch', 'checked',
+  'class', 'const', 'continue', 'default', 'delegate', 'do', 'else', 'enum', 'event',
+  'explicit', 'extern', 'false', 'finally', 'fixed', 'for', 'foreach', 'from', 'get',
+  'global', 'goto', 'if', 'implicit', 'in', 'init', 'interface', 'internal', 'into', 'is',
+  'join', 'let', 'lock', 'namespace', 'new', 'null', 'on', 'operator', 'orderby', 'out',
+  'override', 'params', 'partial', 'private', 'protected', 'public', 'readonly', 'record',
+  'ref', 'remove', 'required', 'return', 'sealed', 'select', 'set', 'sizeof', 'stackalloc',
+  'static', 'struct', 'switch', 'this', 'throw', 'true', 'try', 'typeof', 'unchecked',
+  'unsafe', 'using', 'value', 'virtual', 'volatile', 'when', 'where', 'while', 'with', 'yield',
+])
+
+export const typeKeywords = new Set([
+  'bool', 'byte', 'char', 'decimal', 'double', 'dynamic', 'float', 'int', 'long', 'nint',
+  'nuint', 'object', 'sbyte', 'short', 'string', 'uint', 'ulong', 'ushort', 'void',
+])
+
+export { onCommentEnd, onCommentStart }

package/lib/presets/lang/css.js

@@ -1,4 +1,9 @@
 // @ts-check
+import {
+  T_BREAK, T_CLASS, T_COMMENT, T_IDENTIFIER, T_PROPERTY, T_SIGN, T_SPACE,
+} from '../../shared.js'
+import { tokenize as tokenizePlain } from '../../core.js'
+
 export const keywords = new Set([
   // css keywords like @media, @import, @keyframes, etc.
   '@media', '@import', '@keyframes', '@font-face', '@supports', '@page', '@counter-style',
@@ -12,3 +17,84 @@ export const onCommentStart = (currentChar, nextChar) => {
 export const onCommentEnd = (prevChar, currChar) => {
   return '*/' === (prevChar + currChar) ? 1 : 0
 }
+
+export const onLiteral = (curr, index, code) => {
+  if (curr !== '#') return 0
+  return code.slice(index).match(/^#(?:[\da-f]{8}|[\da-f]{6}|[\da-f]{4}|[\da-f]{3})(?![\w-])/i)?.[0].length || 0
+}
+
+const isIgnored = (type) => type === T_SPACE || type === T_BREAK || type === T_COMMENT
+const isPropertyPart = ([type, value]) =>
+  type === T_IDENTIFIER || type === T_CLASS || (type === T_SIGN && value === '-')
+
+/** Return true when a colon belongs to a nested selector instead of a declaration. */
+const opensBlock = (tokens, start) => {
+  let parentheses = 0
+  let brackets = 0
+  for (let index = start; index < tokens.length; index++) {
+    const [type, value] = tokens[index]
+    if (type !== T_SIGN) continue
+    if (value === '(') parentheses++
+    else if (value === ')') parentheses--
+    else if (value === '[') brackets++
+    else if (value === ']') brackets--
+    else if (!parentheses && !brackets && value === '{') return true
+    else if (!parentheses && !brackets && (value === ';' || value === '}')) return false
+  }
+  return false
+}
+
+/**
+ * Add CSS declaration context after the shared plain lexer runs.
+ * @param {string} code
+ * @param {import('../../core.js').ParseOptions} options
+ */
+export const tokenize = (code, options) => {
+  const tokens = tokenizePlain(code, { ...options, tokenize: undefined })
+  let blockDepth = 0
+  let declarationStart = false
+
+  for (let index = 0; index < tokens.length; index++) {
+    const [type, value] = tokens[index]
+
+    if (type === T_SIGN && value === '{') {
+      blockDepth++
+      declarationStart = true
+      continue
+    }
+    if (type === T_SIGN && value === '}') {
+      blockDepth--
+      declarationStart = false
+      continue
+    }
+    if (type === T_SIGN && value === ';') {
+      declarationStart = blockDepth > 0
+      continue
+    }
+    if (!declarationStart || isIgnored(type)) continue
+
+    const propertyStart = index
+    let propertyEnd = index
+    while (propertyEnd < tokens.length && isPropertyPart(tokens[propertyEnd])) {
+      propertyEnd++
+    }
+    let colon = propertyEnd
+    while (colon < tokens.length && isIgnored(tokens[colon][0])) colon++
+
+    if (
+      propertyEnd > propertyStart &&
+      tokens[colon]?.[0] === T_SIGN &&
+      tokens[colon][1] === ':' &&
+      !opensBlock(tokens, colon + 1)
+    ) {
+      const property = tokens
+        .slice(propertyStart, propertyEnd)
+        .map(([, part]) => part)
+        .join('')
+      tokens.splice(propertyStart, propertyEnd - propertyStart, [T_PROPERTY, property])
+    }
+    declarationStart = false
+  }
+
+  return tokens
+}

package/lib/presets/lang/diff.js

@@ -2,10 +2,16 @@
 
 export const keywords = new Set([])
 
-export const lineClassName = (line) => {
-  if (line.startsWith('+') && !line.startsWith('+++')) return 'sh__line--diff-add'
-  if (line.startsWith('-') && !line.startsWith('---')) return 'sh__line--diff-remove'
-  if (line.startsWith('@@')) return 'sh__line--diff-hunk'
-  if (/^(diff --git|index |--- |\+\+\+ )/.test(line)) return 'sh__line--diff-meta'
-  return undefined
+export const annotateLine = (line) => {
+  let annotation = ''
+  if (line.value.startsWith('+') && !line.value.startsWith('+++')) annotation = 'diff-add'
+  else if (line.value.startsWith('-') && !line.value.startsWith('---')) annotation = 'diff-remove'
+  else if (line.value.startsWith('@@')) annotation = 'diff-hunk'
+  else if (/^(diff --git|index |--- |\+\+\+ )/.test(line.value)) {
+    annotation = 'diff-meta'
+    for (const token of line.tokens) {
+      if (token.type === 'property') token.type = 'identifier'
+    }
+  }
+  if (annotation) line.annotations.push(annotation)
 }

package/lib/presets/lang/dockerfile.js

@@ -0,0 +1,5 @@
+// @ts-check
+import { onCommentEnd, onCommentStart } from './hash-comment-base.js'
+export const caseInsensitive = true
+export const keywords = new Set(['add','arg','cmd','copy','entrypoint','env','expose','from','healthcheck','label','maintainer','onbuild','run','shell','stopsignal','user','volume','workdir'])
+export { onCommentEnd, onCommentStart }

package/lib/presets/lang/graphql.js

@@ -0,0 +1,5 @@
+// @ts-check
+import { onCommentEnd, onCommentStart } from './hash-comment-base.js'
+export const keywords = new Set(['directive','enum','extend','fragment','implements','input','interface','mutation','on','query','repeatable','scalar','schema','subscription','type','union'])
+export const typeKeywords = new Set(['Boolean','Float','ID','Int','String'])
+export { onCommentEnd, onCommentStart }

package/lib/presets/lang/hash-comment-base.js

@@ -0,0 +1,7 @@
+// @ts-check
+
+/** @param {string} currentChar */
+export const onCommentStart = (currentChar) => currentChar === '#' ? 1 : 0
+
+/** @param {string} _prevChar @param {string} currChar */
+export const onCommentEnd = (_prevChar, currChar) => currChar === '\n' ? 1 : 0

package/lib/presets/lang/hcl.js

@@ -0,0 +1,4 @@
+// @ts-check
+export const keywords = new Set(['false','for','if','in','null','true'])
+export const onCommentStart = (curr, next) => curr === '#' ? 1 : curr + next === '//' ? 1 : curr + next === '/*' ? 2 : 0
+export const onCommentEnd = (prev, curr) => curr === '\n' ? 1 : prev + curr === '*/' ? 2 : 0

package/lib/presets/lang/html.js

@@ -0,0 +1,14 @@
+// @ts-check
+import { tokenize as tokenizeJavaScript } from './javascript-runtime.js'
+
+export const keywords = new Set([])
+export const jsx = true
+export const regex = false
+export const templateStrings = false
+export const tokenize = tokenizeJavaScript
+
+export const onCommentStart = (_currentChar, _nextChar, index, code) =>
+  code.startsWith('<!--', index) ? 2 : 0
+
+export const onCommentEnd = (_prevChar, _currChar, index, code) =>
+  code.slice(index - 2, index + 1) === '-->' ? 2 : 0